Solucionado (ver solução)
Solucionado
(ver solução)
2
respostas

Dúvida no await, WhenAll e WaitAll

pessoal,

estou com muita dificuldade em saber quando usar await, WhenAll e WaitAll.

Estou fazendo uns testes usando async e await para retornar qual o diretório que mais tem arquivos no pc. Fiz o exemplo baseado no que foi feito pelo byte bank (mesma estrutura) em um console application. Porém, ao usar o WHENALL, a aplicação fechou e não esperou terminar na linha return await Task.WhenAll(t);

A única diferente é que eu execute o Task.Factory.StartNew e ele cria somente 1 thread e não 10 como era no caso de consolidar.

Quero dominar esse assunto porque é de grande interesse aqui. Obrigado!

2 respostas
solução!

Olá, Rodrigo

Você pode postar aqui o código para darmos uma olhada? Talvez a(s) task(s) já tenham todas terminado quando o programa chegou na linha do Task.WhenAll. Será que é isso?

Ae professor! Obrigado pela ajuda. É isso mesmo, eu fiz confusão com a forma de trabalhar no console application com WPF no curso.

Segue o código:

    public class Program
    {
        public static void Main(string[] args)
        {
            ExecutarVerificarMaiorParanaue();
        }

        public async static void ExecutarVerificarMaiorParanaue()
        {
            var resultado = await VerificarMaiorParanaue();

            Console.Write($"{resultado.Item1} - {resultado.Item2}");

            Console.ReadKey();
        }

        public async static Task<Tuple<string, int>> VerificarMaiorParanaue()
        {
            var task = Task.Factory.StartNew(() =>
            {
                var pasta = "";
                var qtd = 0;

                foreach (var dir in Directory.EnumerateDirectories(@"C:\Program Files", "*.*", SearchOption.AllDirectories))
                {
                    var num = Directory.EnumerateFiles(dir, "0*.txt").Count();

                    if (num > qtd)
                    {
                        qtd = num;
                        pasta = dir;
                    }
                }

                return new Tuple<string, int>(pasta, qtd);
            });

            return (await Task.WhenAll(task))[0];
        }
    }

Aqui onde trabalho, fazemos muitos processamentos pesados de texto e muitos programas são console app, por isso testei no console application.

Outra coisa engraçada é que nos programas que fazemos, apesar de ser uma tarefa pesada que demora horas (depende do tamanho do arquivo), não vejo o processamento indo a 100% o tempo todo como vemos no curso.

Tem alguma forma de identificação mais fácil sobre esses processamentos e qual cor ele tá sendo executado ou até mesmo outros detalhes que possam orientar no desenvolvimento das thread/tasks?