Suppressing "warning CS4014: Because this call is not awaited, execution of the current method continues..."

This is not a duplicate of "How to safely call an async method in C# without await".

How do I nicely suppress the following warning?

> warning 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.

A simple example:

static async Task WorkAsync()
{
    await Task.Delay(1000);
    Console.WriteLine("Done!");
}

static async Task StartWorkAsync()
{
    WorkAsync(); // I want fire-and-forget 

    // more unrelated async/await stuff here, e.g.:
    // ...
    await Task.Delay(2000); 
}

What I tried and did not like:

static async Task StartWorkAsync()
{
    #pragma warning disable 4014
    WorkAsync(); // I want fire-and-forget here
    #pragma warning restore 4014
    // ...
}

static async Task StartWorkAsync()
{
    var ignoreMe = WorkAsync(); // I want fire-and-forget here
    // ...
}

Updated, since the original accepted answer has been edited, I've changed the accepted answer to the one using C# 7.0 discards, as I don't think ContinueWith is appropriate here. Whenever I need to log exceptions for fire-and-forget operations, I use a more elaborate approach proposed by Stephen Cleary here.

With C# 7 you can now use discards:

_ = WorkAsync();

You can create an extension method that will prevent the warning. The extension method can be empty or you can add exception handling with .ContinueWith() there.

static class TaskExtensions
{
    public static void Forget(this Task task)
    {
        task.ContinueWith(
            t => { WriteLog(t.Exception); },
            TaskContinuationOptions.OnlyOnFaulted);
    }
}

public async Task StartWorkAsync()
{
    this.WorkAsync().Forget();
}

---

However ASP.NET counts the number of running tasks, so it will not work with the simple Forget() extension as listed above and instead may fail with the exception: >An asynchronous module or handler completed while an asynchronous operation was still pending.

With .NET 4.5.2 it can be solved by using HostingEnvironment.QueueBackgroundWorkItem:

public static Task HandleFault(this Task task, CancellationToken cancelToken)
{
    return task.ContinueWith(
        t => { WriteLog(t.Exception); },
        cancelToken,
        TaskContinuationOptions.OnlyOnFaulted,
        TaskScheduler.Default);
}

public async Task StartWorkAsync()
{
    System.Web.Hosting.HostingEnvironment.QueueBackgroundWorkItem(
        cancelToken => this.WorkAsync().HandleFault(cancelToken));
}

My two way of dealing with this.

Save it to a discard variable (C# 7)

Example

_ = Task.Run(() => DoMyStuff()).ConfigureAwait(false);

Since the introduction of discards in C# 7, I now consider this to be better than supressing the warning. Because it not only supresses the warning, but also makes the fire-and-forget intention clear.

Moreover, the compiler will be able to optimize it away in release mode.

Just suppress it

#pragma warning disable 4014
...
#pragma warning restore 4014

is a nice enough solution to "fire and forget".

The reason why this warning exists is because in many cases it is not your intention to use an method that returns task without awaiting it. Suppressing the warning when you do intend to fire and forget makes sense.

If you have trouble remembering how to spell #pragma warning disable 4014, simply let Visual Studio add it for you. Press Ctrl+. to open "Quick Actions" and then "Suppress CS2014"

All in all

It's stupid to create a method that takes a few more ticks to execute, just for the purpose of suppressing a warning.

You can decorate the method with the following attribute:

[System.Diagnostics.CodeAnalysis.SuppressMessage("Await.Warning", "CS4014:Await.Warning")]
static async Task StartWorkAsync()
{
    WorkAsync();
    // ...
}

Basically you are telling the compiler that you know what you are doing and it does not need to worry about possible mistake.

The important part of this code is the second parameter. The "CS4014:" part is what suppresses the warning. You can write anything you want on the rest.

An easy way of stopping the warning is to simply assign the Task when calling it:

Task fireAndForget = WorkAsync(); // No warning now

And so in your original post you would do:

static async Task StartWorkAsync()
{
    // Fire and forget
    var fireAndForget = WorkAsync(); // Tell the compiler you know it's a task that's being returned 

    // more unrelated async/await stuff here, e.g.:
    // ...
    await Task.Delay(2000); 
}

The reason for the warning is WorkAsync is returning a Task that is never read or awaited. You can set the return type of WorkAsync to void and the warning will go away.

Typically a method returns a Task when the caller needs to know the status of the worker. In the case of a fire-and-forget, void should be returned to resemble that the caller is independent of the called method.

static async void WorkAsync()
{
    await Task.Delay(1000);
    Console.WriteLine("Done!");
}

static async Task StartWorkAsync()
{
    WorkAsync(); // no warning since return type is void

    // more unrelated async/await stuff here, e.g.:
    // ...
    await Task.Delay(2000); 
}

Why not wrap it inside an async method that returns void ? A bit lengthy but all variables are used.

static async Task StartWorkAsync()
{   
     async void WorkAndForgetAsync() => await WorkAsync();
     WorkAndForgetAsync(); // no warning
}

I found this approach by accident today. You can define a delegate and assign the async method to the delegate first.

    delegate Task IntermediateHandler();

   

    static async Task AsyncOperation()
    {
        await Task.Yield();
    }

and call it like so

(new IntermediateHandler(AsyncOperation))();

...

I thought it was interesting that the compiler wouldn't give the exact same warning when using the delegate.