Métodos assíncronos são convenientes, pois executam trabalhos de longa duração sem bloquear a thread chamadora, isto é, a thread que originou a execução do método assíncrono pode prosseguir a sua execução sem que seja necessário esperar pelo término do método em execução.

Operações tradicionais de criação de métodos assíncronos podem ser complicadas de serem implementadas, sendo difíceis de serem escritas, debugadas e mantidas. Métodos async correm contra estas complicações e facilitam todo o processo de manutenção e criação de métodos assíncronos devido a sua sintaxe enxuta.

A palavra-chave async posicionada antes da definição do tipo de dados de um método (ou lambda expression, ou método anônimo) indica que o mesmo é assíncrono.

Ao invocar um método assíncrono a thread chamadora segue em execução síncrona até encontrar uma expressão wait. Neste instante a execução do método é suspensa é até que a expressão wait seja completada. Neste meio tempo, o fluxo de execução retorna para o ponto chamador do método assíncrono. Se o método assíncrono não contiver nenhuma expressão await então o método será executado sincronamente e será gerado um warning em tempo de compilação do projeto.

Métodos async não podem conter parâmetros out ou ref, e seus tipos de retorno devem ser Task, Task<T> ou void.

O assincronismo é essencial em atividades que geram potencial bloqueio sobre a aplicação. Acessar recursos distribuídos pode se tornar uma tarefa custosa e lenta. Se uma atividade é bloqueada por um procedimento síncrono, então toda a aplicação deve esperar por este procedimento. A execução de um procedimento assíncrono permite que a aplicação continue a trabalhar, independente da execução realizada em paralelo.

O assincronismo provê valor especial para aplicações que utilizam interfaces visuais, pois os componentes da interface visual geralmente compartilham de uma mesma threads. Desta forma, quando utilizamos métodos async, a aplicação continua com a sua interface visual respondendo as interações do usuário, pois a execução em paralelo não compartilha da mesma thread.

A tabela a seguir apresenta as típicas áreas onde a programação assíncrona pode ser empregada. As APIs listadas abaixo e o Windows Runtime contém métodos que suportam async methods.

Área de aplicação APIs que suportam métodos async.

Web access	HttpClient, SyndicationClient
Working with files	StorageFile, StreamWriter, StreamReader, XmlReader
Working with images	MediaCapture, BitmapEncoder, BitmapDecoder
WCF programming	Synchronous and Asynchronous Operations

Exemplo

O código abaixo demonstra o uso de async methods.

using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

class Program {
    static void Main(string[] args) {

        Console.WriteLine("Iniciando execução.");
        Task<int> asyncResult = ExecuteSomeAsyncJob();

        Console.WriteLine("Aguardando o término do método assíncrono.");
        do {

            Console.Write(".");
        } while (!asyncResult.IsCompleted);

        Console.WriteLine("Console base thread ID: {0}", Thread.CurrentThread.ManagedThreadId);

        Console.Read();
    }

    static async Task<int> ExecuteSomeAsyncJob() {

        HttpClient client = new HttpClient();

        Console.WriteLine("Executando síncronamente.");

        string urlContents = await client.GetStringAsync("http://msdn.microsoft.com");

        Console.WriteLine("Fim da tarefa assíncrona.");

        Console.WriteLine("Async thread ID: {0}", Thread.CurrentThread.ManagedThreadId);

        return urlContents.Length;
    }
}

 

Diferenças entre async methods e tasks

Com o uso de Tasks acabamos por ter um controle maior sobre o processo de execução das threads. Conseguimos coordenar a execução de cada Task por meio de métodos como Start, Wait, WaitOne e WaitAll. Com Tasks podemos alinhar diferentes atividades para serem executadas ao mesmo tempo e darem prosseguimento a execução da aplicação quando as mesmas estiverem completas.

Async methods tem um simples objetivo: tornar o processo de codificação de métodos assíncronos mais simples. Podemos implementar métodos assíncronos por meio de Tasks, mas os async methods permitem que isso seja feito de forma mais simples, isto é, com menos código.

Assim, os async methods são mais simples, pois são uma evolução sintática do C# para que a execução de métodos assíncronos seja simplificada. Como o próprio lançamento da feature diz: "Write asynchronous code in an easy and intuitive way".

FH

 

Referências:

http://msdn.microsoft.com/en-us/library/hh156513.aspx

http://msdn.microsoft.com/en-us/library/vstudio/bb386063(v=vs.110).aspx

http://msdn.microsoft.com/en-us/library/vstudio/hh191443(v=vs.110).aspx

http://msdn.microsoft.com/en-us/library/vstudio/hh156528(v=vs.110).aspx

http://www.israelaece.com/post/O-Framework-possibilita-a-Linguagem-facilita.aspx

http://www.israelaece.com/category/Async.aspx