Otimizando chamadas assincronas com Task.WhenAll

Imagine que temos uma classe VeiculoService e dentro dela dois métodos (ObterCarros e ObterMotos). E esses métodos fazem uma busca em uma base de dados "recheada", o que faz cada um deles levar 5 segundos para retornar cada informação.

    public class VeiculoService
    {
        public async Task<string> ObterCarros(string marca)
        {
            await Task.Delay(5000);
            return $"Conclui busca de veiculos da marca {marca}";
        }

        public async Task<string> ObterMotos(string marca)
        {
            await Task.Delay(5000);
            return $"Conclui busca de Motos da marca {marca}";
        }
    }

Agora imagine que temos um programa que precise fazer a chamada desses dois métodos para retornar essas duas listas:

    class Program
    {
        static async Task Main(string[] args)
        {
            var veiculoService = new VeiculoService();

            var carros = await veiculoService.ObterCarros("xpto");
            var motos = await veiculoService.ObterMotos("xpto");

            Console.WriteLine(carros);
            Console.WriteLine(motos);
        }
    }

No código acima nós instanciamos a classe VeiculoService, chamamos o seu método ObterCarros, guardamos em uma variável e logo em seguida chamamos o método ObterMotos guardando também em outra variável. Por fim printamos na tela os dois resultados.

Ao executar o programa observamos que o tempo de processo foi em torno de 10 segundos. Isso porque estamos excutando os dois métodos em sequencia e os dois levam aproximadamente 5s para serem executados.

É possível diminuir consideravelmente esse tempo de processo com o método Task.WhenAll:

    class Program
    {
        static async Task Main(string[] args)
        {
            var veiculoService = new VeiculoService();

            var veiculos = veiculoService.ObterCarros("xpto");
            var marcas = veiculoService.ObterMotos("xpto");

            await Task.WhenAll(veiculos, marcas);

            Console.WriteLine(veiculos.Result);
            Console.WriteLine(marcas.Result);
        }
    }

Observando o console, podemos ver que o tempo de execução caiu pela metade:

Isso acontece pois o Task.WhenAll executa os métodos em paralelo. O que é muito útil para casos em que temos varias chamadas de métodos que não dependem do resultado um do outro, salvando um tempo que muitas vezes pode ser precioso para o seu programa.