C# How to start an async method without await its complete?

Question

Sometimes I need to start an async job which works very slow. I don't care if that job success and I need to continue working on my current thread.

Like sometimes I need to send an Email or SMS which works very slow. I need to respond to the web client as soon as possible so I don't want to await it.

I have googled this question and some articles suggest me to write like this:

// This method has to be async public async Task<Response> SomeHTTPAction() {     // Some logic...     // ...      // Send an Email but don't care if it successfully sent.     Task.Run(() =>  _emailService.SendEmailAsync());     return MyRespond(); } 

Or like this:

// This method has to be async public async Task<Response> SomeHTTPAction() {     // Some logic...     // ...      // Send an Email but don't care if it successfully sent.     Task.Factory.StartNew(() =>  _emailService.SendEmailAsync());     return MyRespond(); } 

There will be a warning says: before the call is completed. Consider applying the 'await' operator to the result of the call.

So what if I really awaited it? What is the best practice in C# to 'fire and forget', just call an async method without waiting for its complete?

Answer 1

If you truly just want to fire and forget. Simply don't call use await.

// It is a good idea to add CancellationTokens var asyncProcedure = SomeHTTPAction(cancellationToken).ConfigureAwait(false);  // Or If not simply do: var asyncProcedure = SomeHTTPAction().ConfigureAwait(false); 

If you want to use the result output later its gets trickier. But if it is truly fire and forget the above should work

A Cancellation token allows interrupts and canceling procedures. If you are using Cancellation token you will need to use it everywhere from the retrieval straight through to the calling method (Turtles all the way down).

I used ConfigureAwait(false) to prevent deadlocks. Here for more information

Answer 2

A standalone discard is the best way to avoid this warning.

_ = Task.Run(() =>  _emailService.SendEmailAsync()); 

Discards are dummy variables and can be used to ignore the Task object returned by an asynchronous operation.

https://docs.microsoft.com/en-us/dotnet/csharp/discards#a-standalone-discard