Führen Sie zwei asynchrone Aufgaben parallel aus und sammeln Sie Ergebnisse in .NET 4.5

Ich habe eine Weile versucht, etwas zu bekommen, von dem ich dachte, dass es einfach wäre, mit .NET 4.5 zu arbeiten

Ich möchte zwei lange laufende Aufgaben gleichzeitig starten und die
Ergebnisse auf die beste C # 4.5 (RTM) -Methode sammeln

Folgendes funktioniert, aber ich mag es nicht, weil:

• Ich möchte Sleepeine asynchrone Methode sein, damit es auch awaitandere Methoden können
• Es sieht nur ungeschickt aus Task.Run()
• Ich denke nicht, dass dies überhaupt neue Sprachfunktionen verwendet!

Arbeitscode:

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;
}

Nicht funktionierender Code:

Update: Dies funktioniert tatsächlich und ist der richtige Weg, das einzige Problem ist das Thread.Sleep

Dieser Code funktioniert nicht, da der Aufruf zum Sleep(5000)sofortigen Starten der ausgeführten Aufgabe Sleep(1000)erst nach Abschluss ausgeführt wird. Dies ist wahr, obwohl es Sleepist asyncund ich nicht benutzeawait oder .Resultzu früh anrufe.

Ich dachte, es gibt vielleicht eine Möglichkeit, Task<T>durch Aufrufen einer asyncMethode eine Nicht-Ausführung zu erreichen , damit ich dann Start()die beiden Aufgaben aufrufen kann, aber ich kann nicht herausfinden, wie ich Task<T>durch Aufrufen einer asynchronen Methode eine erhalten kann.

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;
}

Sie sollten Task.Delay anstelle von Sleep für die asynchrone Programmierung verwenden und dann Task.WhenAll verwenden, um die Aufgabenergebnisse zu kombinieren. Die Aufgaben würden parallel ausgeführt.

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
}

Während Ihre SleepMethode asynchron ist,Thread.Sleep ist dies nicht der . Die ganze Idee von Async besteht darin, einen einzelnen Thread wiederzuverwenden und nicht mehrere Threads zu starten. Da Sie die Verwendung eines synchronen Aufrufs von Thread.Sleep blockiert haben, funktioniert dies nicht.

Ich gehe davon aus Thread.Sleep eine Vereinfachung dessen ist, was Sie tatsächlich tun möchten. Kann Ihre tatsächliche Implementierung als asynchrone Methode codiert werden?

Wenn Sie mehrere synchrone Blockierungsanrufe ausführen müssen, schauen Sie woanders, denke ich!

Um diesen Punkt zu beantworten:

Ich möchte, dass Sleep eine asynchrone Methode ist, damit sie auf andere Methoden warten kann

Sie können die SleepFunktion möglicherweise folgendermaßen umschreiben :

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();
}

Wenn Sie diesen Code ausführen, wird Folgendes ausgegeben:

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

Es ist jetzt Wochenende !

    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;
    }

Dieser Artikel hat viele Dinge erklärt. Es ist im FAQ-Stil.

Async / Await FAQ

Dieser Teil erklärt, warum Thread.Sleepauf demselben ursprünglichen Thread ausgeführt wird - was zu meiner anfänglichen Verwirrung führt.

Verursacht das Schlüsselwort "async" den Aufruf einer Methode, die in die Warteschlange des ThreadPool gestellt wird? So erstellen Sie einen neuen Thread? Ein Raketenschiff zum Mars starten?

Nein. Und nein. Siehe die vorherigen Fragen. Das Schlüsselwort "async" gibt dem Compiler an, dass "await" innerhalb der Methode verwendet werden kann, sodass die Methode an einem Wartepunkt angehalten und ihre Ausführung asynchron fortgesetzt werden kann, wenn die erwartete Instanz abgeschlossen ist. Aus diesem Grund gibt der Compiler eine Warnung aus, wenn in einer als "asynchron" gekennzeichneten Methode keine "Wartezeiten" vorhanden sind.