Apa perbedaan antara Task.Start / Tunggu dan Async / Tunggu?

Saya mungkin kehilangan sesuatu tetapi apa perbedaan antara melakukan:

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

Saya mungkin kehilangan sesuatu

Kamu adalah.

apa perbedaan antara melakukan Task.Waitdan await task?

Anda memesan makan siang dari pelayan di restoran. Sesaat setelah memberikan pesanan Anda, seorang teman berjalan masuk dan duduk di sebelah Anda dan memulai percakapan. Sekarang kamu punya dua pilihan. Anda dapat mengabaikan teman Anda sampai tugas selesai - Anda dapat menunggu sampai sup Anda tiba dan tidak melakukan apa pun saat Anda menunggu. Atau Anda dapat menanggapi teman Anda, dan ketika teman Anda berhenti berbicara, pelayan akan membawakan Anda sup.

Task.Waitblok sampai tugas selesai - Anda mengabaikan teman Anda sampai tugas selesai. awaitterus memproses pesan dalam antrian pesan, dan ketika tugas selesai, ia meminta pesan yang mengatakan "ambil tempat Anda tinggalkan setelah itu menunggu". Anda berbicara dengan teman Anda, dan ketika ada jeda dalam percakapan sup tiba.

Untuk menunjukkan jawaban Eric di sini ada beberapa kode:

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

Contoh ini menunjukkan perbedaannya dengan sangat jelas. Dengan async / menunggu utas panggilan tidak akan memblokir dan melanjutkan eksekusi.

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

Output DoAsTask:

[1] Program Mulai
[1] 1 - Mulai
[1] 2 - Tugas dimulai
[3] A - Memulai sesuatu
[3] B - Menyelesaikan sesuatu
[1] 3 - Tugas diselesaikan dengan hasil: 123
[1] Akhir Program

Output DoAsAsync:

[1] Program Mulai
[1] 1 - Mulai
[1] 2 - Tugas dimulai
[3] A - Memulai sesuatu
[1] Akhir Program
[3] B - Menyelesaikan sesuatu
[3] 3 - Tugas diselesaikan dengan hasil: 123

Pembaruan: Contoh yang ditingkatkan dengan menampilkan ID utas di output.

Tunggu (), akan menyebabkan kode async berpotensi dijalankan secara sinkron. menunggu tidak akan.

Misalnya, Anda memiliki aplikasi web asp.net. Panggilan pengguna / getUser / 1 titik akhir. kumpulan aplikasi asp.net akan memilih utas dari utas (Thread1) dan, utas ini akan melakukan panggilan http. Jika Anda Tunggu (), utas ini akan diblokir sampai panggilan http diselesaikan. Saat sedang menunggu, jika UserB memanggil / getUser / 2, maka, kumpulan aplikasi perlu melayani utas lainnya (Thread2) untuk membuat panggilan http lagi. Anda baru saja membuat (Sebenarnya, diambil dari kumpulan aplikasi) utas lainnya tanpa alasan, karena Anda tidak dapat menggunakan Thread1 karena diblokir oleh Tunggu ().

Jika Anda menggunakan menunggu di Thread1, maka, SyncContext akan mengelola sinkronisasi antara panggilan Thread1 dan http. Cukup, ini akan memberi tahu setelah panggilan http selesai. Sementara itu, jika UserB melakukan panggilan / getUser / 2, maka, Anda akan menggunakan Thread1 lagi untuk melakukan panggilan http, karena itu dirilis setelah menunggu ditabrak. Kemudian permintaan lain dapat menggunakannya, bahkan lebih jauh lagi. Setelah panggilan http selesai (user1 atau user2), Thread1 bisa mendapatkan hasilnya dan kembali ke pemanggil (klien). Thread1 digunakan untuk banyak tugas.

Dalam contoh ini, tidak banyak, praktis. Jika Anda sedang menunggu tugas yang kembali pada utas yang berbeda (seperti panggilan WCF) atau melepaskan kontrol ke sistem operasi (seperti File IO), menunggu akan menggunakan lebih sedikit sumber daya sistem dengan tidak memblokir utas.

Pada contoh di atas, Anda dapat menggunakan "TaskCreationOptions.HideScheduler", dan sangat memodifikasi metode "DoAsTask". Metode itu sendiri tidak asinkron, seperti yang terjadi dengan "DoAsAsync" karena mengembalikan nilai "Tugas" dan ditandai sebagai "async", membuat beberapa kombinasi, ini adalah bagaimana ia memberi saya persis sama dengan menggunakan "async / menunggu" :

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