Task.Run'u zaman uyumsuz hale getirmek için bir yönteme mi koymak zorundasınız?

Asenkronun en basit haliyle beklediğini anlamaya çalışıyorum. Bu örnek uğruna iki sayı ekleyen çok basit bir yöntem oluşturmak istiyorum, verilmiş, hiç işlem süresi yok, sadece burada bir örnek formüle etme meselesi.

örnek 1

private async Task DoWork1Async()
{
    int result = 1 + 2;
}

ÖRNEK 2

private async Task DoWork2Async()
{
    Task.Run( () =>
    {
        int result = 1 + 2;
    });
}

Ben beklersem DoWork1Async()kod senkronize veya senkronize olmayan çalışır mı?

Task.RunUI iş parçacığını engellememek için yöntemi beklenebilir ve asenkron hale getirmek için senkronizasyon kodunu sarmam gerekir mi?

Benim yöntem bir Taskveya döner olup olmadığını anlamaya çalışıyorum Task<T>ben Task.Runeşzamansız yapmak için kodu sarmak gerekir .

Aptal soru eminim ama insanların içinde bir şey asenk vardır ve sarılmış değil kod bekleyen net örneklere bakın Task.Runya StartNew.

İlk olarak, bazı terminolojileri temizleyelim: "asenkron" ( async), başlamadan önce çağıran iş parçacığına geri denetim sağlayabileceği anlamına gelir. Bir asyncyöntemde, bu "verim" noktaları awaitifadelerdir.

MSDN belgeleri tarafından "arka plan iş parçacığında yürütülür" anlamında yıllardır kullanılan (mis) olarak "asenkron" teriminden çok farklıdır.

Sorunu daha da karıştırmak, async"beklenebilir" den çok farklıdır; asyncdönüş türleri beklenmeyen bazı yöntemler ve beklenmeyen türleri döndüren birçok yöntem vardır async.

Onlar neyi kadar yeter değildir ; işte budur şunlardır :

• asyncAnahtar kelime (olduğunu, bu sağlayan bir asenkron metot verir awaitifadeler). asyncyöntemler döndürebilir Task, Task<T>(Gerekirse) veya void.
• Belirli bir modeli izleyen herhangi bir tür beklenebilir. En yaygın beklenen tipler Taskve Task<T>.

Bu nedenle, sorunuzu "bir işlemi bir arka plan iş parçacığında beklenen şekilde nasıl çalıştırabilirim" olarak yeniden biçimlendirirsek , yanıt şu şekildedir Task.Run:

private Task<int> DoWorkAsync() // No async because the method does not need await
{
  return Task.Run(() =>
  {
    return 1 + 2;
  });
}

(Ancak bu model kötü bir yaklaşımdır; aşağıya bakınız).

Ancak sorunuz " asyncengelleme yerine arayanına nasıl geri dönebilecek bir yöntem oluştururum " ise, yanıt yöntemi bildirmek asyncve await"sağlama" noktaları için kullanmaktır :

private async Task<int> GetWebPageHtmlSizeAsync()
{
  var client = new HttpClient();
  var html = await client.GetAsync("http://www.example.com/");
  return html.Length;
}

Yani, şeylerin temel paterni async, awaitifadelerinde “beklenebilir” olan koda bağımlı olmaktır . Bu "beklenenler" diğer asyncyöntemler veya sadece beklenenleri döndüren normal yöntemler olabilir. Dönen Düzenli yöntemler Task/ Task<T> edebilirsiniz kullanmak Task.Run, bir arka plan iş parçacığı üzerinde kod çalıştırmak için, ya da (daha yaygın) kullanabilecekleri TaskCompletionSource<T>veya kısayolları (biri TaskFactory.FromAsync, Task.FromResultvs). Ben yok bütün bir yöntem içinde sarma tavsiye Task.Run; eşzamanlı yöntemlerin eşzamanlı imzaları olmalıdır ve aşağıdakilere sarılıp sarılmayacağı tüketiciye bırakılmalıdır Task.Run:

private int DoWork()
{
  return 1 + 2;
}

private void MoreSynchronousProcessing()
{
  // Execute it directly (synchronously), since we are also a synchronous method.
  var result = DoWork();
  ...
}

private async Task DoVariousThingsFromTheUIThreadAsync()
{
  // I have a bunch of async work to do, and I am executed on the UI thread.
  var result = await Task.Run(() => DoWork());
  ...
}

Bir var async/ awaitintro blogumda; sonunda bazı iyi takip kaynakları vardır. İçin MSDN belgeleri asyncde alışılmadık derecede iyi.

Bir yöntemi zaman uyumsuz olarak dekore ederken hatırlanması gereken en önemli şeylerden biri, en azından yöntemin içinde bir bekleyen operatörün olmasıdır. Örneğinizde, TaskCompletionSource kullanarak aşağıda gösterildiği gibi çeviririm .

private Task<int> DoWorkAsync()
{
    //create a task completion source
    //the type of the result value must be the same
    //as the type in the returning Task
    TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();
    Task.Run(() =>
    {
        int result = 1 + 2;
        //set the result to TaskCompletionSource
        tcs.SetResult(result);
    });
    //return the Task
    return tcs.Task;
}

private async void DoWork()
{
    int result = await DoWorkAsync();
}

Bir yöntemi çalıştırmak için Task.Run kullandığınızda, Görev o yöntemi çalıştırmak için threadpool bir iş parçacığı alır. Bu yüzden UI iş parçacığının bakış açısından, UI iş parçacığını engellemediğinden "asenkron" olur.Bu, kullanıcı etkileşimlerine dikkat etmek için genellikle birçok iş parçacığına ihtiyacınız olmadığı için masaüstü uygulaması için iyidir.

Ancak, web uygulaması için her bir talebe bir iş parçacığı havuzu iş parçacığı tarafından hizmet edilir ve böylece bu tür iş parçacıkları kaydedilerek etkin isteklerin sayısı artırılabilir. Sıklıkla eşzamansız işlemi simüle etmek için threadpool iş parçacıklarını kullanmak web uygulamaları için ölçeklenebilir değildir.

True Async, dosya / DB erişimi vb. Gibi G / Ç işlemleri için bir iş parçacığı kullanmayı gerektirmez. G / Ç işleminin neden iş parçacığı gerektirmediğini anlamak için bunu okuyabilirsiniz. http://blog.stephencleary.com/2013/11/there-is-no-thread.html

Basit örneğinizde, saf bir CPU'ya bağlı hesaplamadır, bu yüzden Task.Run kullanmak iyidir.