Acabei de adquirir o VS2012 e tentar entender async.

Digamos que eu tenho um método que busca algum valor de uma fonte de bloqueio. Não quero que o chamador do método seja bloqueado. Eu poderia escrever o método para receber um retorno de chamada que é chamado quando o valor chega, mas como estou usando o C # 5, decido tornar o método assíncrono para que os chamadores não precisem lidar com retornos de chamada:

// contrived example (edited in response to Servy's comment)
public static Task<string> PromptForStringAsync(string prompt)
{
    return Task.Factory.StartNew(() => {
        Console.Write(prompt);
        return Console.ReadLine();
    });
}

Aqui está um método de exemplo que o chama. Se PromptForStringAsyncnão fosse assíncrono, esse método exigiria o aninhamento de um retorno de chamada em um retorno de chamada. Com o async, escrevo meu método dessa maneira muito natural:

public static async Task GetNameAsync()
{
    string firstname = await PromptForStringAsync("Enter your first name: ");
    Console.WriteLine("Welcome {0}.", firstname);

    string lastname = await PromptForStringAsync("Enter your last name: ");
    Console.WriteLine("Name saved as '{0} {1}'.", firstname, lastname);
}

Por enquanto, tudo bem. O problema é quando eu chamo GetNameAsync:

public static void DoStuff()
{
    GetNameAsync();
    MainWorkOfApplicationIDontWantBlocked();
}

O ponto principal GetNameAsyncé que é assíncrono. Não quero que ele bloqueie, porque quero voltar para o MainWorkOfApplicationIDontWantBlocked o mais rápido possível e permitir que GetNameAsync faça suas coisas em segundo plano. No entanto, chamar dessa maneira me dá um aviso do compilador na GetNameAsynclinha:

Warning 1   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.

Estou perfeitamente ciente de que "a execução do método atual continua antes que a chamada seja concluída". Esse é o objetivo do código assíncrono, certo?

Prefiro que meu código seja compilado sem avisos, mas não há nada para "corrigir" aqui, porque o código está fazendo exatamente o que pretendo fazer. Posso me livrar do aviso armazenando o valor de retorno de GetNameAsync:

public static void DoStuff()
{
    var result = GetNameAsync(); // supress warning
    MainWorkOfApplicationIDontWantBlocked();
}

Mas agora eu tenho código supérfluo. O Visual Studio parece entender que fui forçado a escrever esse código desnecessário, porque suprime o aviso "valor nunca usado" normal.

Também posso me livrar do aviso envolvendo GetNameAsync em um método que não é assíncrono:

    public static Task GetNameWrapper()
    {
        return GetNameAsync();
    }

Mas esse é um código ainda mais supérfluo. Portanto, tenho que escrever um código que não preciso ou tolero um aviso desnecessário.

Existe algo sobre meu uso de assíncrono errado aqui?

Se você realmente não precisa do resultado, pode simplesmente mudar a GetNameAsyncassinatura para retornar void:

public static async void GetNameAsync()
{
    ...
}

Considere a resposta a uma pergunta relacionada: Qual é a diferença entre retornar nulo e retornar uma tarefa?

Atualizar

Se você precisar do resultado, poderá alterar GetNameAsyncpara retornar, digamos Task<string>:

public static async Task<string> GetNameAsync()
{
    string firstname = await PromptForStringAsync("Enter your first name: ");
    string lastname = await PromptForStringAsync("Enter your last name: ");
    return firstname + lastname;
}

E use-o da seguinte maneira:

public static void DoStuff()
{
    Task<string> task = GetNameAsync();

    // Set up a continuation BEFORE MainWorkOfApplicationIDontWantBlocked
    Task anotherTask = task.ContinueWith(r => {
            Console.WriteLine(r.Result);
        });

    MainWorkOfApplicationIDontWantBlocked();

    // OR wait for the result AFTER
    string result = task.Result;
}

Estou muito atrasado para esta discussão, mas também há a opção de usar a #pragmadiretiva pré-processador. Eu tenho um código assíncrono aqui e ali que, explicitamente, não quero aguardar em algumas condições, e não gosto de avisos e variáveis ​​não utilizadas, assim como o resto de vocês:

#pragma warning disable 4014
SomeMethodAsync();
#pragma warning restore 4014

O "4014"vem desta página MSDN: Compiler Aviso (nível 1) CS4014 .

Consulte também o aviso / resposta de @ ryan-horath aqui https://stackoverflow.com/a/12145047/928483 .

Exceções lançadas durante uma chamada assíncrona que não é esperada serão perdidas. Para se livrar desse aviso, você deve atribuir o valor de retorno de tarefa da chamada assíncrona a uma variável. Isso garante que você tenha acesso a quaisquer exceções lançadas, que serão indicadas no valor de retorno.

Atualização para C # 7.0

O C # 7.0 adiciona um novo recurso, descarte variáveis: Descartes - Guia de C # , que também pode ajudar nesse sentido.

_ = SomeMethodAsync();

Não gosto particularmente das soluções que atribuem a tarefa a uma variável não utilizada ou alteram a assinatura do método para retornar nulo. O primeiro cria código supérfluo e não intuitivo, enquanto o último pode não ser possível se você estiver implementando uma interface ou tiver outro uso da função em que deseja usar a tarefa retornada.

Minha solução é criar um método de extensão da tarefa, chamado DoNotAwait () que não faz nada. Isso não apenas suprimirá todos os avisos, ReSharper ou outros, mas também tornará o código mais compreensível e indicará aos futuros mantenedores do seu código que você realmente pretendia que a chamada não fosse aguardada.

Método de extensão:

public static class TaskExtensions
{
    public static void DoNotAwait(this Task task) { }
}

Uso:

public static void DoStuff()
{
    GetNameAsync().DoNotAwait();
    MainWorkOfApplicationIDontWantBlocked();
}

Editado para adicionar: isso é semelhante à solução de Jonathan Allen, em que o método de extensão iniciaria a tarefa se ainda não tiver sido iniciado, mas eu prefiro ter funções de finalidade única para que a intenção do chamador seja completamente clara.

async void É RUIM!

1. Qual é a diferença entre retornar nulo e retornar uma tarefa?
2. https://jaylee.org/archive/2012/07/08/c-sharp-async-tips-and-tricks-part-2-async-void.html

O que eu sugiro é que você execute explicitamente o Taskmétodo anônimo ...

por exemplo

public static void DoStuff()
{
    Task.Run(async () => GetNameAsync());
    MainWorkOfApplicationIDontWantBlocked();
}

Ou, se você quiser bloquear, aguarde o método anônimo

public static void DoStuff()
{
    Task.Run(async () => await GetNameAsync());
    MainWorkOfApplicationThatWillBeBlocked();
}

No entanto, se o seu GetNameAsyncmétodo precisar interagir com a interface do usuário ou com qualquer coisa vinculada à interface do usuário (WINRT / MVVM, estou olhando para você), ficará um pouco mais engraçado =)

Você precisará passar a referência ao expedidor da interface do usuário desta maneira ...

Task.Run(async () => await GetNameAsync(CoreApplication.MainView.CoreWindow.Dispatcher));

E então, no seu método assíncrono, você precisará interagir com a interface do usuário ou com os elementos vinculados à interface do usuário, como o expedidor ...

dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {  this.UserName = userName; });

Isto é o que estou fazendo atualmente:

SomeAyncFunction().RunConcurrently();

Onde RunConcurrentlyé definido como ...

 /// <summary> 
 /// Runs the Task in a concurrent thread without waiting for it to complete. This will start the task if it is not already running. 
 /// </summary> 
 /// <param name="task">The task to run.</param> 
 /// <remarks>This is usually used to avoid warning messages about not waiting for the task to complete.</remarks> 
 public static void RunConcurrently(this Task task) 
 { 
     if (task == null) 
         throw new ArgumentNullException("task", "task is null."); 

     if (task.Status == TaskStatus.Created) 
         task.Start(); 
 } 

https://github.com/docevaad/Anchor/blob/master/Tortuga.Anchor/Tortuga.Anchor.source/shared/TaskUtilities.cs

https://www.nuget.org/packages/Tortuga.Anchor/

De acordo com o artigo da Microsoft sobre este aviso, você pode resolvê-lo simplesmente atribuindo a tarefa retornada a uma variável. Abaixo está uma tradução do código fornecido no exemplo da Microsoft:

    // 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, the recommended practice is always to
    // await a call to an async method.
    // Replace Call #1 with the following line.
    Task delayTask = CalledMethodAsync(delay);

Observe que isso resultará na mensagem "A variável local nunca é usada" no ReSharper.

Aqui, uma solução simples.

public static class TasksExtensions
{
    public static void RunAndForget(this Task task)
    {
    }
}

Saudações

É o seu exemplo simplificado que causa o código supérfluo. Normalmente, você deseja usar os dados que foram buscados a partir da fonte de bloqueio em algum momento do programa, para que você deseje o resultado de volta para que seja possível acessar os dados.

Se você realmente tem algo que acontece totalmente isolado do resto do programa, a assíncrona não seria a abordagem correta. Basta iniciar um novo thread para essa tarefa.

Deseja realmente ignorar o resultado? como na inclusão de ignorar exceções inesperadas?

Caso contrário, você pode querer dar uma olhada nesta pergunta: Abordar o fogo e esquecer ,

Se você não deseja alterar a assinatura do método para retornar void(como retornar voidsempre deve ser um nulo ), você pode usar o recurso de descarte do C # 7.0+ como este, que é um pouco melhor do que atribuir a uma variável (e deve remover a maioria dos outros avisos das ferramentas de validação de fonte):

public static void DoStuff()
{
    _ = GetNameAsync(); // we don't need the return value (suppresses warning)
    MainWorkOfApplicationIDontWantBlocked();
}