Exécutez deux tâches asynchrones en parallèle et collectez les résultats dans .NET 4.5

J'essaie depuis un moment d'obtenir quelque chose que je pensais être simple de travailler avec .NET 4.5

Je veux lancer deux tâches longues en même temps et collecter les
résultats de la meilleure façon C # 4.5 (RTM)

Ce qui suit fonctionne mais je n'aime pas ça parce que:

• Je veux Sleepêtre une méthode asynchrone pour pouvoir awaitutiliser d'autres méthodes
• Ça a l'air maladroit avec Task.Run()
• Je ne pense même pas que cela utilise de nouvelles fonctionnalités linguistiques!

Code de travail:

public static void Go()
{
    Console.WriteLine("Starting");

    var task1 = Task.Run(() => Sleep(5000));    
    var task2 = Task.Run(() => Sleep(3000));

    int totalSlept = task1.Result + task2.Result;

    Console.WriteLine("Slept for a total of " + totalSlept + " ms");
}

private static int Sleep(int ms)
{
    Console.WriteLine("Sleeping for " + ms);
    Thread.Sleep(ms);
    Console.WriteLine("Sleeping for " + ms + " FINISHED");
    return ms;
}

Code non fonctionnel:

Mise à jour: cela fonctionne réellement et c'est la bonne façon de le faire, le seul problème est le Thread.Sleep

Ce code ne fonctionne pas car l'appel à Sleep(5000)lance immédiatement la tâche en cours d'exécution et Sleep(1000)ne s'exécute donc pas tant qu'elle n'est pas terminée. C'est vrai même si Sleepc'est le cas asyncet je n'utilise pas awaitou n'appelle pas .Resulttrop tôt.

J'ai pensé qu'il y avait peut-être un moyen d'obtenir un non-en cours Task<T>d' exécution en appelant une asyncméthode afin que je puisse ensuite appeler Start()les deux tâches, mais je ne peux pas comprendre comment obtenir un en Task<T>appelant une méthode asynchrone.

public static void Go()
{
    Console.WriteLine("Starting");

    var task1 = Sleep(5000);    // blocks
    var task2 = Sleep(1000);

    int totalSlept = task1.Result + task2.Result;

    Console.WriteLine("Slept for " + totalSlept + " ms");
}

private static async Task<int> Sleep(int ms)
{
    Console.WriteLine("Sleeping for " + ms);
    Thread.Sleep(ms);
    return ms;
}

Vous devez utiliser Task.Delay au lieu de Sleep pour la programmation asynchrone, puis utiliser Task.WhenAll pour combiner les résultats de la tâche. Les tâches seraient exécutées en parallèle.

public class Program
    {
        static void Main(string[] args)
        {
            Go();
        }
        public static void Go()
        {
            GoAsync();
            Console.ReadLine();
        }
        public static async void GoAsync()
        {

            Console.WriteLine("Starting");

            var task1 = Sleep(5000);
            var task2 = Sleep(3000);

            int[] result = await Task.WhenAll(task1, task2);

            Console.WriteLine("Slept for a total of " + result.Sum() + " ms");

        }

        private async static Task<int> Sleep(int ms)
        {
            Console.WriteLine("Sleeping for {0} at {1}", ms, Environment.TickCount);
            await Task.Delay(ms);
            Console.WriteLine("Sleeping for {0} finished at {1}", ms, Environment.TickCount);
            return ms;
        }
    }

async Task<int> LongTask1() { 
  ...
  return 0; 
}

async Task<int> LongTask2() { 
  ...
  return 1; 
}

...
{
   Task<int> t1 = LongTask1();
   Task<int> t2 = LongTask2();
   await Task.WhenAll(t1,t2);
   //now we have t1.Result and t2.Result
}

Bien que votre Sleepméthode soit asynchrone, ce Thread.Sleepn'est pas le cas. L'idée générale de l'async est de réutiliser un seul thread, et non de démarrer plusieurs threads. Parce que vous avez bloqué à l'aide d'un appel synchrone à Thread.Sleep, cela ne fonctionnera pas.

Je suppose que Thread.Sleepc'est une simplification de ce que vous voulez réellement faire. Votre implémentation réelle peut-elle être codée en tant que méthodes asynchrones?

Si vous avez besoin d'exécuter plusieurs appels de blocage synchrones, regardez ailleurs je pense!

Pour répondre à ce point:

Je veux que Sleep soit une méthode asynchrone afin qu'elle puisse attendre d'autres méthodes

vous pouvez peut-être réécrire la Sleepfonction comme ceci:

private static async Task<int> Sleep(int ms)
{
    Console.WriteLine("Sleeping for " + ms);
    var task = Task.Run(() => Thread.Sleep(ms));
    await task;
    Console.WriteLine("Sleeping for " + ms + "END");
    return ms;
}

static void Main(string[] args)
{
    Console.WriteLine("Starting");

    var task1 = Sleep(2000);
    var task2 = Sleep(1000);

    int totalSlept = task1.Result +task2.Result;

    Console.WriteLine("Slept for " + totalSlept + " ms");
    Console.ReadKey();
}

l'exécution de ce code produira:

Starting
Sleeping for 2000
Sleeping for 1000
*(one second later)*
Sleeping for 1000END
*(one second later)*
Sleeping for 2000END
Slept for 3000 ms

C'est le week - end maintenant!

    public async void Go()
    {
        Console.WriteLine("Start fosterage...");

        var t1 = Sleep(5000, "Kevin");
        var t2 = Sleep(3000, "Jerry");
        var result = await Task.WhenAll(t1, t2);

        Console.WriteLine($"My precious spare time last for only {result.Max()}ms");
        Console.WriteLine("Press any key and take same beer...");
        Console.ReadKey();
    }

    private static async Task<int> Sleep(int ms, string name)
    {
            Console.WriteLine($"{name} going to sleep for {ms}ms :)");
            await Task.Delay(ms);
            Console.WriteLine("${name} waked up after {ms}ms :(";
            return ms;
    }

Cet article a permis d'expliquer beaucoup de choses. C'est dans le style FAQ.

FAQ sur Async / Await

Cette partie explique pourquoi Thread.Sleepfonctionne sur le même fil d'origine - menant à ma confusion initiale.

Le mot-clé «async» provoque-t-il l'appel d'une méthode à la file d'attente vers ThreadPool? Pour créer un nouveau fil? Lancer une fusée sur Mars?

Non, non. Et non. Voir les questions précédentes. Le mot clé «async» indique au compilateur que «await» peut être utilisé à l'intérieur de la méthode, de sorte que la méthode peut se suspendre à un point d'attente et avoir son exécution reprise de manière asynchrone lorsque l'instance attendue se termine. C'est pourquoi le compilateur émet un avertissement s'il n'y a pas de "waits" à l'intérieur d'une méthode marquée comme "async".