Farklı sonuçlarla birden fazla Görev bekleniyor

3 görevim var:

private async Task<Cat> FeedCat() {}
private async Task<House> SellHouse() {}
private async Task<Tesla> BuyCar() {}

Hepsi kodum devam etmeden önce çalışması gerekiyor ve ben de her sonuçlara ihtiyacım var. Sonuçların hiçbirinin birbiriyle ortak bir yanı yok

3 görevi tamamlayıp sonuçları almak için nasıl ararım ve beklerim?

Kullandıktan sonra WhenAll, sonuçları aşağıdakilerle ayrı ayrı çıkarabilirsiniz await:

var catTask = FeedCat();
var houseTask = SellHouse();
var carTask = BuyCar();

await Task.WhenAll(catTask, houseTask, carTask);

var cat = await catTask;
var house = await houseTask;
var car = await carTask;

Ayrıca kullanabilirsiniz Task.Result(bu noktaya kadar hepsi başarıyla tamamlandığını bildiğiniz için). Ancak, diğer senaryolarda sorunlara neden olabileceği için awaitaçıkça doğru olduğu için kullanmanızı öneririm Result.

Sadece awaithepsini başladıktan sonra ayrı ayrı üç görevi.

var catTask = FeedCat();
var houseTask = SellHouse();
var carTask = BuyCar();

var cat = await catTask;
var house = await houseTask;
var car = await carTask;

C # 7 kullanıyorsanız, böyle kullanışlı bir sarmalama yöntemi kullanabilirsiniz ...

public static class TaskEx
{
    public static async Task<(T1, T2)> WhenAll<T1, T2>(Task<T1> task1, Task<T2> task2)
    {
        return (await task1, await task2);
    }
}

... farklı dönüş türlerine sahip birden çok görevi beklemek istediğinizde, bu gibi uygun sözdizimini etkinleştirmek için. Elbette, beklemek için farklı sayıda görev için birden fazla aşırı yükleme yapmanız gerekir.

var (someInt, someString) = await TaskEx.WhenAll(GetIntAsync(), GetStringAsync());

Ancak, bu örneği gerçek bir şeye dönüştürmek istiyorsanız, ValueTask ve zaten tamamlanmış görevler hakkındaki bazı optimizasyonlar için Marc Gravell'in cevabına bakın.

Verilen üç görevi - FeedCat(), SellHouse()veBuyCar() , iki ilginç durumlar vardır: ya onlar (nedense, belki de önbelleğe veya bir hata) tüm komple eşzamanlı veya onlar değil.

Diyelim ki sorudan:

Task<string> DoTheThings() {
    Task<Cat> x = FeedCat();
    Task<House> y = SellHouse();
    Task<Tesla> z = BuyCar();
    // what here?
}

Şimdi, basit bir yaklaşım şöyle olacaktır:

Task.WhenAll(x, y, z);

ancak ... sonuçların işlenmesi için uygun değildir; tipik olarak bunu yapmak awaitisteriz:

async Task<string> DoTheThings() {
    Task<Cat> x = FeedCat();
    Task<House> y = SellHouse();
    Task<Tesla> z = BuyCar();

    await Task.WhenAll(x, y, z);
    // presumably we want to do something with the results...
    return DoWhatever(x.Result, y.Result, z.Result);
}

ancak bu çok fazla yük oluşturur ve çeşitli dizileri ( params Task[]dizi dahil ) ve listeleri (dahili olarak) ayırır. Çalışıyor, ama harika IMO değil. Birçok yönden bir işlemi kullanmak daha kolaydırasync ve awaither biri sırayla:

async Task<string> DoTheThings() {
    Task<Cat> x = FeedCat();
    Task<House> y = SellHouse();
    Task<Tesla> z = BuyCar();

    // do something with the results...
    return DoWhatever(await x, await y, await z);
}

Kullanarak yukarıdaki bazı yorumlar, aksine awaityerine Task.WhenAllmarkaların fark görevleri (eş zamanlı, sıralı, vs) çalıştırmak nasıl. En yüksek düzeyde, / için iyi derleyici desteğinden Task.WhenAll önce gelir ve bu şeyler olmadığında yararlı oldu . Ayrıca, 3 gizli görev yerine rastgele bir dizi göreviniz olduğunda da kullanışlıdır.asyncawait

Ancak: devam için çok fazla derleyici gürültüsü üreten async/ awaitüreten bir sorun var . O görevler olması mümkündür olabilir aslında eşzamanlı tamamlamak, o zaman uyumsuz bir yedek kullanımıyla bir senkron yolunda inşa ederek bu optimize edebilirsiniz:

Task<string> DoTheThings() {
    Task<Cat> x = FeedCat();
    Task<House> y = SellHouse();
    Task<Tesla> z = BuyCar();

    if(x.Status == TaskStatus.RanToCompletion &&
       y.Status == TaskStatus.RanToCompletion &&
       z.Status == TaskStatus.RanToCompletion)
        return Task.FromResult(
          DoWhatever(a.Result, b.Result, c.Result));
       // we can safely access .Result, as they are known
       // to be ran-to-completion

    return Awaited(x, y, z);
}

async Task Awaited(Task<Cat> a, Task<House> b, Task<Tesla> c) {
    return DoWhatever(await x, await y, await z);
}

Bu "eşzamansız geri dönüş ile eşitleme" yaklaşımı, özellikle eşzamanlı tamamlamaların nispeten sık olduğu yüksek performanslı kodda giderek yaygınlaşmaktadır. Tamamlamanın her zaman gerçekten eşzamansız olması durumunda hiç yardımcı olmayacağını unutmayın.

Burada geçerli olan ek şeyler:

1. son C # ile, ortak bir model, asyncgeri dönüş yöntemi genellikle yerel bir işlev olarak uygulanır:

   Task<string> DoTheThings() {
       async Task<string> Awaited(Task<Cat> a, Task<House> b, Task<Tesla> c) {
           return DoWhatever(await a, await b, await c);
       }
       Task<Cat> x = FeedCat();
       Task<House> y = SellHouse();
       Task<Tesla> z = BuyCar();
   
       if(x.Status == TaskStatus.RanToCompletion &&
          y.Status == TaskStatus.RanToCompletion &&
          z.Status == TaskStatus.RanToCompletion)
           return Task.FromResult(
             DoWhatever(a.Result, b.Result, c.Result));
          // we can safely access .Result, as they are known
          // to be ran-to-completion
   
       return Awaited(x, y, z);
   }

2. tercih ValueTask<T>etmek Task<T>çok farklı dönüş değerleri ile şimdiye tamamen eşzamanlı şeylerin iyi bir şans varsa:

   ValueTask<string> DoTheThings() {
       async ValueTask<string> Awaited(ValueTask<Cat> a, Task<House> b, Task<Tesla> c) {
           return DoWhatever(await a, await b, await c);
       }
       ValueTask<Cat> x = FeedCat();
       ValueTask<House> y = SellHouse();
       ValueTask<Tesla> z = BuyCar();
   
       if(x.IsCompletedSuccessfully &&
          y.IsCompletedSuccessfully &&
          z.IsCompletedSuccessfully)
           return new ValueTask<string>(
             DoWhatever(a.Result, b.Result, c.Result));
          // we can safely access .Result, as they are known
          // to be ran-to-completion
   
       return Awaited(x, y, z);
   }

3. Mümkünse, tercih IsCompletedSuccessfullyetmek Status == TaskStatus.RanToCompletion; bu artık .NET Core'da Taskve her yerde varValueTask<T>

Onları görevlerde saklayabilir, sonra hepsini bekleyebilirsiniz:

var catTask = FeedCat();
var houseTask = SellHouse();
var carTask = BuyCar();

await Task.WhenAll(catTask, houseTask, carTask);

Cat cat = await catTask;
House house = await houseTask;
Car car = await carTask;

Tüm hataları günlüğe kaydetmeye çalışıyorsanız, Task.WhenAll satırını kodunuzda tuttuğunuzdan emin olun, çok sayıda yorum onu ​​kaldırabileceğinizi ve bireysel görevleri bekleyebileceğinizi gösterir. Görev.Ne zaman hata işleme için gerçekten önemlidir. Bu satır olmadan, kodunuzu gözlemlenmeyen istisnalar için açık bırakabilirsiniz.

var catTask = FeedCat();
var houseTask = SellHouse();
var carTask = BuyCar();

await Task.WhenAll(catTask, houseTask, carTask);

var cat = await catTask;
var house = await houseTask;
var car = await carTask;

FeedCat'in aşağıdaki kodda istisna oluşturduğunu düşünün:

var catTask = FeedCat();
var houseTask = SellHouse();
var carTask = BuyCar();

var cat = await catTask;
var house = await houseTask;
var car = await carTask;

Bu durumda asla houseTask veya carTask'ta beklemeyeceksiniz. Burada 3 olası senaryo vardır:

1. FeedCat başarısız olduğunda SellHouse zaten başarıyla tamamlandı. Bu durumda iyisin.

2. SellHouse tam değildir ve bir noktada istisna dışında başarısız olur. İstisna gözlenmez ve sonlandırıcı iplikte yeniden görüntülenir.

3. SellHouse tam değil ve içinde bekliyor. Kodunuzun ASP.NET'te çalıştırılması durumunda, bazı beklemeler içinde tamamlanır tamamlanmaz başarısız olur. Bunun nedeni, FeedCat başarısız olur olmaz temelde ateşle & unut araması ve senkronizasyon bağlamının kaybolmasıdır.

Dava (3) için alacağınız hata:

System.AggregateException: A Task's exception(s) were not observed either by Waiting on the Task or accessing its Exception property. As a result, the unobserved exception was rethrown by the finalizer thread. ---> System.NullReferenceException: Object reference not set to an instance of an object.
   at System.Web.ThreadContext.AssociateWithCurrentThread(Boolean setImpersonationContext)
   at System.Web.HttpApplication.OnThreadEnterPrivate(Boolean setImpersonationContext)
   at System.Web.HttpApplication.System.Web.Util.ISyncContext.Enter()
   at System.Web.Util.SynchronizationHelper.SafeWrapCallback(Action action)
   at System.Threading.Tasks.Task.Execute()
   --- End of inner exception stack trace ---
---> (Inner Exception #0) System.NullReferenceException: Object reference not set to an instance of an object.
   at System.Web.ThreadContext.AssociateWithCurrentThread(Boolean setImpersonationContext)
   at System.Web.HttpApplication.OnThreadEnterPrivate(Boolean setImpersonationContext)
   at System.Web.HttpApplication.System.Web.Util.ISyncContext.Enter()
   at System.Web.Util.SynchronizationHelper.SafeWrapCallback(Action action)
   at System.Threading.Tasks.Task.Execute()<---

Durum (2) için benzer bir hata alırsınız, ancak orijinal istisna yığını izlemesiyle.

.NET 4.0 ve sonraki sürümler için TaskScheduler.UnobservedTaskException kullanarak gözlemlenmeyen özel durumları yakalayabilirsiniz. .NET 4.5 ve sonraki sürümlerde gözlemlenmeyen özel durumlar varsayılan olarak yutulur. NET 4.0 için gözlenmeyen özel durum işleminizin çökmesine neden olur.

Daha fazla ayrıntı burada: .NET 4.5'te Görev Özel Durumu İşleme

Task.WhenAllBelirtildiği gibi veya Task.WaitAlliş parçacığının beklemesini isteyip istemediğinize bağlı olarak kullanabilirsiniz . Her ikisinin açıklaması için bağlantıya bir göz atın.

WaitAll ve WhenAll

Kullanın Task.WhenAllve ardından sonuçları bekleyin:

var tCat = FeedCat();
var tHouse = SellHouse();
var tCar = BuyCar();
await Task.WhenAll(tCat, tHouse, tCar);
Cat cat = await tCat;
House house = await tHouse;
Tesla car = await tCar; 
//as they have all definitely finished, you could also use Task.Value.

İleri Uyarı

Bu ve benzeri konuları ziyaret edenlere, async + await + görev araç setini kullanarak EntityFramework'i paralelleştirmenin bir yolunu arayanlara hızlı bir başlangıç : Burada gösterilen desen , ancak EF'in özel kar tanesi söz konusu olduğunda, dahil olan her * Async () çağrısının içinde ayrı (yeni) db-context-örneği kullanmadığınız sürece ve buna kadar paralel yürütme elde edin.

Bu tür bir şey, aynı ef-db-bağlam örneğinde paralel olarak birden çok sorguyu çalıştırmayı yasaklayan ef-db-bağlamlarının doğal tasarım sınırlamaları nedeniyle gereklidir.

Daha önce verilen cevaplardan yararlanarak, görevlerden biri veya daha fazlasının istisna oluşturması durumunda bile tüm değerleri topladığınızdan emin olmanın yolu budur:

  public async Task<string> Foobar() {
    async Task<string> Awaited(Task<Cat> a, Task<House> b, Task<Tesla> c) {
        return DoSomething(await a, await b, await c);
    }

    using (var carTask = BuyCarAsync())
    using (var catTask = FeedCatAsync())
    using (var houseTask = SellHouseAsync())
    {
        if (carTask.Status == TaskStatus.RanToCompletion //triple
            && catTask.Status == TaskStatus.RanToCompletion //cache
            && houseTask.Status == TaskStatus.RanToCompletion) { //hits
            return Task.FromResult(DoSomething(catTask.Result, carTask.Result, houseTask.Result)); //fast-track
        }

        cat = await catTask;
        car = await carTask;
        house = await houseTask;
        //or Task.AwaitAll(carTask, catTask, houseTask);
        //or await Task.WhenAll(carTask, catTask, houseTask);
        //it depends on how you like exception handling better

        return Awaited(catTask, carTask, houseTask);
   }
 }

Aşağı yukarı aynı performans özelliklerine sahip alternatif bir uygulama şunlar olabilir:

 public async Task<string> Foobar() {
    using (var carTask = BuyCarAsync())
    using (var catTask = FeedCatAsync())
    using (var houseTask = SellHouseAsync())
    {
        cat = catTask.Status == TaskStatus.RanToCompletion ? catTask.Result : (await catTask);
        car = carTask.Status == TaskStatus.RanToCompletion ? carTask.Result : (await carTask);
        house = houseTask.Status == TaskStatus.RanToCompletion ? houseTask.Result : (await houseTask);

        return DoSomething(cat, car, house);
     }
 }

var dn = await Task.WhenAll<dynamic>(FeedCat(),SellHouse(),BuyCar());

Cat'e erişmek istiyorsanız, bunu yapın:

var ct = (Cat)dn[0];

Bunu yapmak çok basit ve kullanımı çok yararlı, karmaşık bir çözümden sonra gitmeye gerek yok.