Task.Start / Wait ve Async / Await arasındaki fark nedir?

Bir şey eksik olabilir ama yapmak arasındaki fark nedir:

public void MyMethod()
{
  Task t = Task.Factory.StartNew(DoSomethingThatTakesTime);
  t.Wait();
  UpdateLabelToSayItsComplete();
}

public async void MyMethod()
{
  var result = Task.Factory.StartNew(DoSomethingThatTakesTime);
  await result;
  UpdateLabelToSayItsComplete();
}

private void DoSomethingThatTakesTime()
{
  Thread.Sleep(10000);
}

Bir şey kaçırıyor olabilirim

Sen.

doing Task.Waitve arasındaki fark await tasknedir?

Öğle yemeğini restoranda garsondan sipariş edersiniz. Siparişinizi verdikten bir dakika sonra, bir arkadaşınız içeri girer ve yanınızda oturur ve bir konuşma başlatır. Şimdi iki seçeneğiniz var. Görev tamamlanana kadar arkadaşınızı görmezden gelebilirsiniz - çorbanız gelene kadar bekleyebilir ve beklerken başka bir şey yapamazsınız. Ya da arkadaşınıza cevap verebilirsiniz ve arkadaşınız konuşmayı bıraktığında, garson size çorbanızı getirecektir.

Task.Waitgörev tamamlanana kadar engeller - görev tamamlanana kadar arkadaşınızı yok sayarsınız. awaitiletileri ileti kuyruğunda işlemeye devam eder ve görev tamamlandığında "bekledikten sonra kaldığınız yerden devam et" yazan bir iletiyi sırayla söyler. Arkadaşınızla konuşuyorsunuz ve konuşmada bir ara olduğunda çorba geliyor.

Eric'in cevabını burada göstermek için bazı kodlar var:

public void ButtonClick(object sender, EventArgs e)
{
  Task t = new Task.Factory.StartNew(DoSomethingThatTakesTime);
  t.Wait();  
  //If you press Button2 now you won't see anything in the console 
  //until this task is complete and then the label will be updated!
  UpdateLabelToSayItsComplete();
}

public async void ButtonClick(object sender, EventArgs e)
{
  var result = Task.Factory.StartNew(DoSomethingThatTakesTime);
  await result;
  //If you press Button2 now you will see stuff in the console and 
  //when the long method returns it will update the label!
  UpdateLabelToSayItsComplete();
}

public void Button_2_Click(object sender, EventArgs e)
{
  Console.WriteLine("Button 2 Clicked");
}

private void DoSomethingThatTakesTime()
{
  Thread.Sleep(10000);
}

Bu örnek, farkı çok net bir şekilde göstermektedir. Zaman uyumsuz / beklemede, çağrı dizisi engellenmez ve yürütülmeye devam etmez.

static void Main(string[] args)
{
    WriteOutput("Program Begin");
    // DoAsTask();
    DoAsAsync();
    WriteOutput("Program End");
    Console.ReadLine();
}

static void DoAsTask()
{
    WriteOutput("1 - Starting");
    var t = Task.Factory.StartNew<int>(DoSomethingThatTakesTime);
    WriteOutput("2 - Task started");
    t.Wait();
    WriteOutput("3 - Task completed with result: " + t.Result);
}

static async Task DoAsAsync()
{
    WriteOutput("1 - Starting");
    var t = Task.Factory.StartNew<int>(DoSomethingThatTakesTime);
    WriteOutput("2 - Task started");
    var result = await t;
    WriteOutput("3 - Task completed with result: " + result);
}

static int DoSomethingThatTakesTime()
{
    WriteOutput("A - Started something");
    Thread.Sleep(1000);
    WriteOutput("B - Completed something");
    return 123;
}

static void WriteOutput(string message)
{
    Console.WriteLine("[{0}] {1}", Thread.CurrentThread.ManagedThreadId, message);
}

DoAsTask Çıkışı:

[1] Program Başladı
[1] 1 - Başlatma
[1] 2 - Görev başladı
[3] A - Bir şey başlattı
[3] B - Bir şey tamamladı
[1] 3 - Görev sonuçlandı: 123
[1] Program Sonu

DoAsAsync Çıkışı:

[1] Program Başladı
[1] 1 - Başlatma
[1] 2 - Görev başladı
[3] A - Bir şey başlattı
[1] Program Sonu
[3] B - Bir şey tamamladı
[3] 3 - Görev sonuçlandı: 123

Güncelleme: Çıktıda iş parçacığı kimliğini göstererek geliştirilmiş örnek.

Wait (), eşzamansız olarak eşzamansız kod çalıştırılmasına neden olur. beklemeyeceğim.

Örneğin, bir asp.net web uygulamanız var. UserA / getUser / 1 uç noktasını çağırır. asp.net uygulama havuzu, iş parçacığı havuzundan (Thread1) bir iş parçacığı seçer ve bu iş parçacığı bir http araması yapar. Wait () yaparsanız, http çağrısı çözülene kadar bu iş parçacığı engellenir. Beklerken, UserB / getUser / 2'yi çağırırsa, http çağrısını tekrar yapmak için uygulama havuzunun başka bir iş parçacığı (Thread2) sunması gerekir. Az önce (Eh, aslında uygulama havuzundan getirildi) başka bir iş parçacığı oluşturmadınız, çünkü Thread1'i kullanamıyorsunuz, Wait () tarafından engellendi.

Thread1'de await kullanırsanız, SyncContext Thread1 ve http çağrısı arasındaki senkronizasyonu yönetir. Basitçe, http çağrısı yapıldıktan sonra bunu bildirir. Bu arada, UserB / getUser / 2'yi çağırırsa, http çağrısı yapmak için tekrar Thread1'i kullanacaksınız, çünkü bir kez vurulduktan sonra serbest bırakılmıştır. Daha sonra başka bir istek daha da fazla kullanabilir. Http çağrısı yapıldığında (user1 veya user2), Thread1 sonucu alabilir ve arayan kişiye (istemci) geri dönebilir. Thread1 çoklu görevler için kullanıldı.

Bu örnekte, pratikte fazla değil. Farklı bir iş parçacığında geri dönen (WCF çağrısı gibi) bir Görev bekliyorsanız veya işletim sistemine (Dosya G / Ç gibi) denetimi bırakıyorsa, iş parçacığını engellemeyerek daha az sistem kaynağı kullanır.

Yukarıdaki örnekte, "TaskCreationOptions.HideScheduler" kullanabilir ve "DoAsTask" yöntemini büyük ölçüde değiştirebilirsiniz. "DoAsAsync" ile olduğu gibi yöntemin kendisi eşzamanlı değildir, çünkü bir "Görev" değeri döndürür ve "eşzamansız" olarak işaretlenir, birkaç kombinasyon yapar, bu bana "eşzamansız / beklemede" kullanmakla aynı şekilde verir :

static Task DoAsTask()
{
    WriteOutput("1 - Starting");
    var t = Task.Factory.StartNew<int>(DoSomethingThatTakesTime, TaskCreationOptions.HideScheduler); //<-- HideScheduler do the magic

    TaskCompletionSource<int> tsc = new TaskCompletionSource<int>();
    t.ContinueWith(tsk => tsc.TrySetResult(tsk.Result)); //<-- Set the result to the created Task

    WriteOutput("2 - Task started");

    tsc.Task.ContinueWith(tsk => WriteOutput("3 - Task completed with result: " + tsk.Result)); //<-- Complete the Task
    return tsc.Task;
}