Compiler Warning (level 1) CS4014
Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the await operator to the result of the call.
The current method calls an async method that returns a Task or a Task<TResult> and doesn't apply the await operator to the result. The call to the async method starts an asynchronous task. However, because no await operator is applied, the program continues without waiting for the task to complete. In most cases, that behavior isn't what you expect. Usually other aspects of the calling method depend on the results of the call or, minimally, the called method is expected to complete before you return from the method that contains the call.
An equally important issue is what happens to exceptions that are raised in the called async method. An exception that's raised in a method that returns a Task or Task<TResult> is stored in the returned task. If you don't await the task or explicitly check for exceptions, the exception is lost. If you await the task, its exception is rethrown.
As a best practice, you should always await the call.
You should consider suppressing the warning only if you're sure that you don't want to wait for the asynchronous call to complete and that the called method won't raise any exceptions. In that case, you can suppress the warning by assigning the task result of the call to a variable.
The following example shows how to cause the warning, how to suppress it, and how to await the call.
static async Task CallingMethodAsync(int millisecondsDelay)
{
Console.WriteLine(" Entering calling method.");
// Call #1.
// Call an async method. Because you don't await it, its completion
// isn't coordinated with the current method, CallingMethodAsync.
// The following line causes warning CS4014.
CalledMethodAsync(millisecondsDelay);
// Call #2.
// To suppress the warning without awaiting, you can assign the
// returned task to a variable. The assignment doesn't change how
// the program runs. However, recommended practice is always to
// await a call to an async method.
// Replace Call #1 with the following line.
// Task delayTask = CalledMethodAsync(millisecondsDelay);
// Call #3
// To contrast with an awaited call, replace the unawaited call
// (Call #1 or Call #2) with the following awaited call. Best
// practice is to await the call.
// await CalledMethodAsync(millisecondsDelay);
Console.WriteLine(" Returning from calling method.");
}
static async Task CalledMethodAsync(int millisecondsDelay)
{
Console.WriteLine(" Entering called method, starting and awaiting Task.Delay.");
await Task.Delay(millisecondsDelay);
Console.WriteLine(" Task.Delay is finished--returning from called method.");
}
In the example, if you choose Call #1 or Call #2, the unawaited async method CalledMethodAsync finishes after both its caller CallingMethodAsync and the caller's caller is complete. The last line in the following output shows you when the called method finishes. Entry to and exit from the event handler that calls CallingMethodAsync in the full example are marked in the output.
Entering the Click event handler.
Entering calling method.
Entering called method, starting and awaiting Task.Delay.
Returning from calling method.
Exiting the Click event handler.
Task.Delay is finished--returning from called method.
You can also suppress compiler warnings by using #pragma warning directives.
Example
The following console application contains the methods from the previous example. The following steps set up the application.
Create a console application, and name it
AsyncWarning.In the Visual Studio Code Editor, choose the Program.cs file.
Replace the code in Program.cs with the following code.
using System; using System.Threading.Tasks; namespace AsyncWarning { class Program { static async Task Main() { Console.WriteLine("Entering Main() application entry point."); int millisecondsDelay = 2000; await CallingMethodAsync(millisecondsDelay); Console.WriteLine("Exiting Main() application entry point."); await Task.Delay(millisecondsDelay + 500); } static async Task CallingMethodAsync(int millisecondsDelay) { Console.WriteLine(" Entering calling method."); // Call #1. // Call an async method. Because you don't await it, its completion // isn't coordinated with the current method, CallingMethodAsync. // The following line causes warning CS4014. // CalledMethodAsync(millisecondsDelay); // Call #2. // To suppress the warning without awaiting, you can assign the // returned task to a variable. The assignment doesn't change how // the program runs. However, recommended practice is always to // await a call to an async method. // Replace Call #1 with the following line. //Task delayTask = CalledMethodAsync(millisecondsDelay); // Call #3 // To contrast with an awaited call, replace the unawaited call // (Call #1 or Call #2) with the following awaited call. Best // practice is to await the call. // await CalledMethodAsync(millisecondsDelay); Console.WriteLine(" Returning from calling method."); } static async Task CalledMethodAsync(int millisecondsDelay) { Console.WriteLine(" Entering called method, starting and awaiting Task.Delay."); await Task.Delay(millisecondsDelay); Console.WriteLine(" Task.Delay is finished--returning from called method."); } } // Output with Call #1 or Call #2. (Wait for the last line to appear.) // Entering Main() application entry point. // Entering calling method. // Entering called method, starting and awaiting Task.Delay. // Returning from calling method. // Exiting Main() application entry point. // Task.Delay is finished--returning from called method. // Output with Call #3, which awaits the call to CalledMethodAsync. // Entering Main() application entry point. // Entering calling method. // Entering called method, starting and awaiting Task.Delay. // Task.Delay is finished--returning from called method. // Returning from calling method. // Exiting Main() application entry point. }Select the F5 key to run the program.
The expected output appears at the end of the code.
