Suprimindo “aviso CS4014: Como esta chamada não é aguardada, a execução do método atual continua…”

Esta não é uma duplicata de "Como chamar com segurança um método assíncrono em C # sem aguardar" .

Como suprimo bem o seguinte aviso?

aviso CS4014: Como essa chamada não é aguardada, a execução do método atual continua antes que a chamada seja concluída. Considere aplicar o operador 'aguardar' ao resultado da chamada.

Um exemplo simples:

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); 
}

O que eu tentei e não gostei:

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
    // ...
}

Atualizado , desde que a resposta original aceita foi editada, alterei a resposta aceita para a que está usando as devoluções do C # 7.0 , pois acho que não ContinueWithé apropriado aqui. Sempre que preciso registrar exceções para operações de disparar e esquecer, uso uma abordagem mais elaborada proposta por Stephen Cleary aqui .

Com o C # 7, agora você pode usar descartes :

_ = WorkAsync();

Você pode criar um método de extensão que impedirá o aviso. O método de extensão pode estar vazio ou você pode adicionar um tratamento de exceção .ContinueWith().

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();
}

No entanto, o ASP.NET conta o número de tarefas em execução; portanto, ele não funcionará com a Forget()extensão simples, conforme listado acima, e poderá falhar com a exceção:

Um módulo ou manipulador assíncrono foi concluído enquanto uma operação assíncrona ainda estava pendente.

Com o .NET 4.5.2, ele pode ser resolvido usando 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));
}

Você pode decorar o método com o seguinte atributo:

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

Basicamente, você está dizendo ao compilador que sabe o que está fazendo e não precisa se preocupar com um possível erro.

A parte importante desse código é o segundo parâmetro. A parte "CS4014:" é o que suprime o aviso. Você pode escrever o que quiser sobre o resto.

Minha maneira de lidar com isso.

Salve-o em uma variável de descarte (C # 7)

Exemplo

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

Desde a introdução das devoluções no C # 7, agora considero que isso é melhor do que suprimir o aviso. Porque não apenas suprime o aviso, mas também torna clara a intenção de disparar e esquecer.

Além disso, o compilador poderá otimizá-lo no modo release.

Apenas suprima-o

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

é uma solução bastante agradável para "disparar e esquecer".

A razão pela qual esse aviso existe é que, em muitos casos, não é sua intenção usar um método que retorne uma tarefa sem aguardá-lo. Suprimir o aviso quando você pretende disparar e esquecer faz sentido.

Se você tiver problemas para se lembrar de como se escreve #pragma warning disable 4014, deixe o Visual Studio adicioná-lo para você. Pressione Ctrl +. para abrir "Ações rápidas" e "Suprimir CS2014"

Contudo

É estúpido criar um método que leva mais alguns ticks para executar, apenas com o objetivo de suprimir um aviso.

Uma maneira fácil de interromper o aviso é simplesmente atribuir a tarefa ao chamá-lo:

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

E assim, em sua postagem original, você faria:

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); 
}

O motivo do aviso é que o WorkAsync está retornando um Taskque nunca é lido ou aguardado. Você pode definir o tipo de retorno do WorkAsync para voide o aviso desaparecerá.

Normalmente, um método retorna a Taskquando o chamador precisa saber o status do trabalhador. No caso de um recurso de ignorar, deve-se retornar o nulo para parecer que o chamador é independente do método chamado.

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); 
}

Por que não agrupá-lo dentro de um método assíncrono que retorna nulo? Um pouco longo, mas todas as variáveis ​​são usadas.

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

Encontrei essa abordagem por acidente hoje. Você pode definir um delegado e atribuir o método assíncrono ao delegado primeiro.

    delegate Task IntermediateHandler();



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

e chame assim

(new IntermediateHandler(AsyncOperation))();

...

Eu pensei que era interessante que o compilador não desse exatamente o mesmo aviso ao usar o delegado.