Esegui due attività asincrone in parallelo e raccogli i risultati in .NET 4.5

Ho provato per un po 'di tempo a ottenere qualcosa che pensavo sarebbe stato semplice lavorare con .NET 4.5

Voglio lanciare due attività a lunga esecuzione contemporaneamente e raccogliere i
risultati nel miglior modo C # 4.5 (RTM)

Il seguente funziona ma non mi piace perché:

• Voglio Sleepessere un metodo asincrono in modo che possa utilizzare awaitaltri metodi
• Sembra solo goffo con Task.Run()
• Non penso che questo stia nemmeno usando alcuna nuova funzionalità del linguaggio!

Codice di lavoro:

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

Codice non funzionante:

Aggiornamento: funziona davvero ed è il modo corretto per farlo, l'unico problema è il file Thread.Sleep

Questo codice non funziona perché la chiamata a Sleep(5000)avvia immediatamente l'esecuzione dell'attività, quindi Sleep(1000)non viene eseguita fino al completamento. Questo è vero anche se lo Sleepè asynce non sto usando awaito chiamando .Resulttroppo presto.

Ho pensato che forse ci fosse un modo per ottenere un non in esecuzione Task<T>chiamando un asyncmetodo in modo da poter quindi chiamare Start()le due attività, ma non riesco a capire come ottenerlo Task<T>chiamando un metodo asincrono.

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

È necessario utilizzare Task.Delay invece di Sleep per la programmazione asincrona e quindi utilizzare Task.WhenAll per combinare i risultati dell'attività. Le attività verranno eseguite in parallelo.

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
}

Anche se il tuo Sleepmetodo è asincrono, Thread.Sleepnon lo è. L'intera idea di async è riutilizzare un singolo thread, non avviare più thread. Poiché hai bloccato l'utilizzo di una chiamata sincrona a Thread.Sleep, non funzionerà.

Presumo che Thread.Sleepsia una semplificazione di ciò che vuoi effettivamente fare. La tua implementazione effettiva può essere codificata come metodi asincroni?

Se hai bisogno di eseguire più chiamate di blocco sincrone, guarda altrove, penso!

Per rispondere a questo punto:

Voglio che Sleep sia un metodo asincrono in modo che possa attendere altri metodi

puoi forse riscrivere la Sleepfunzione in questo modo:

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'esecuzione di questo codice produrrà:

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

È il fine settimana adesso!

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

Questo articolo ha aiutato a spiegare molte cose. È in stile FAQ.

Domande frequenti su Async / Await

Questa parte spiega perché Thread.Sleepgira sullo stesso thread originale, portando alla mia confusione iniziale.

La parola chiave "async" fa sì che il richiamo di un metodo venga messo in coda nel ThreadPool? Per creare un nuovo thread? Per lanciare un razzo su Marte?

No. No. E no. Vedi le domande precedenti. La parola chiave "async" indica al compilatore che "await" può essere utilizzato all'interno del metodo, in modo tale che il metodo possa sospendere in un punto di attesa e riprendere la sua esecuzione in modo asincrono al termine dell'istanza attesa. Questo è il motivo per cui il compilatore emette un avviso se non ci sono "attese" all'interno di un metodo contrassegnato come "asincrono".