VS2012'yi aldım ve halletmeye çalışıyorum async.

Diyelim ki engelleme kaynağından bir değer alan bir yöntemim var. Yöntemin arayanının engellemesini istemiyorum. Değer geldiğinde çağrılan bir geri aramayı alma yöntemini yazabilirim, ancak C # 5 kullandığım için, yöntemi zaman uyumsuz yapmaya karar verdim, böylece arayanlar geri aramalarla uğraşmak zorunda kalmazlar:

// contrived example (edited in response to Servy's comment)
public static Task<string> PromptForStringAsync(string prompt)
{
    return Task.Factory.StartNew(() => {
        Console.Write(prompt);
        return Console.ReadLine();
    });
}

İşte onu çağıran örnek bir yöntem. Eğer PromptForStringAsynczaman uyumsuz değildi, bu yöntem bir geri içerisinde bir geri arama yuva gerektirecektir. Async ile yöntemimi şu çok doğal bir şekilde yazıyorum:

public static async Task GetNameAsync()
{
    string firstname = await PromptForStringAsync("Enter your first name: ");
    Console.WriteLine("Welcome {0}.", firstname);

    string lastname = await PromptForStringAsync("Enter your last name: ");
    Console.WriteLine("Name saved as '{0} {1}'.", firstname, lastname);
}

Çok uzak çok iyi. Ben ne zaman sorunudur diyoruz GetNameAsync:

public static void DoStuff()
{
    GetNameAsync();
    MainWorkOfApplicationIDontWantBlocked();
}

Bütün mesele, GetNameAsynceşzamansız olmasıdır. Ben yok istiyorum o ASAP MainWorkOfApplicationIDontWantBlocked geri almak istiyorum, çünkü, engellemek ve GetNameAsync arka planda onun şey yapalım. Ancak, bu şekilde çağırmak bana GetNameAsyncsatırda bir derleyici uyarısı veriyor :

Warning 1   Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call.

"Mevcut yöntemin yürütülmesinin çağrı tamamlanmadan önce devam ettiğinin" tamamen farkındayım. Budur nokta , doğru asenkron kod?

Kodumun uyarı olmadan derlenmesini tercih ederim, ancak burada "düzeltecek" bir şey yok çünkü kod tam olarak yapmak istediğim şeyi yapıyor. Aşağıdakilerin dönüş değerini saklayarak uyarıdan kurtulabilirim GetNameAsync:

public static void DoStuff()
{
    var result = GetNameAsync(); // supress warning
    MainWorkOfApplicationIDontWantBlocked();
}

Ama artık gereksiz kodum var. Visual Studio, normal "hiç kullanılmayan değer" uyarısını bastırdığı için bu gereksiz kodu yazmaya zorlandığımı anlıyor gibi görünüyor.

GetNameAsync'i zaman uyumsuz olmayan bir yöntemde sararak da uyarıdan kurtulabilirim:

    public static Task GetNameWrapper()
    {
        return GetNameAsync();
    }

Ama bu daha da gereksiz bir kod. Bu yüzden kod yazmalıyım, gereksiz bir uyarıya ihtiyacım yok veya hoşgörülü değilim.

Eşzamansız kullanımımla ilgili burada yanlış olan bir şey mi var?

Sonuca gerçekten ihtiyacınız yoksa, GetNameAsyncgeri dönmek için basitçe imzasını değiştirebilirsiniz void:

public static async void GetNameAsync()
{
    ...
}

İlgili bir sorunun cevabını görmeyi düşünün: Boşluğu iade etmek ile bir Görevi geri vermek arasındaki fark nedir?

Güncelleme

Sonuca ihtiyacınız varsa, GetNameAsyncdönüş için değiştirebilirsiniz , örneğin Task<string>:

public static async Task<string> GetNameAsync()
{
    string firstname = await PromptForStringAsync("Enter your first name: ");
    string lastname = await PromptForStringAsync("Enter your last name: ");
    return firstname + lastname;
}

Ve aşağıdaki gibi kullanın:

public static void DoStuff()
{
    Task<string> task = GetNameAsync();

    // Set up a continuation BEFORE MainWorkOfApplicationIDontWantBlocked
    Task anotherTask = task.ContinueWith(r => {
            Console.WriteLine(r.Result);
        });

    MainWorkOfApplicationIDontWantBlocked();

    // OR wait for the result AFTER
    string result = task.Result;
}

Bu tartışmaya oldukça geç kaldım, ancak #pragmaön işlemci yönergesini kullanma seçeneği de var . Burada burada bazı koşullarda beklemek istemediğim bazı eşzamansız kodum var ve tıpkı sizler gibi uyarıları ve kullanılmayan değişkenleri sevmiyorum:

#pragma warning disable 4014
SomeMethodAsync();
#pragma warning restore 4014

Şu "4014"MSDN sayfasından gelir: Derleyici Uyarısı (düzey 1) CS4014 .

Ayrıca @ ryan-horath tarafından gönderilen uyarı / yanıta buradan https://stackoverflow.com/a/12145047/928483 bakın .

Beklenmeyen bir zaman uyumsuz çağrı sırasında atılan istisnalar kaybedilecektir. Bu uyarıdan kurtulmak için, zaman uyumsuz çağrının Görev dönüş değerini bir değişkene atamalısınız. Bu, dönüş değerinde gösterilecek olan tüm istisnalara erişmenizi sağlar.

C # 7.0 için güncelleme

C # 7.0 yeni bir özellik ekler, değişkenleri atar: Atar - C # Kılavuzu , bu konuda da yardımcı olabilir.

_ = SomeMethodAsync();

Görevi kullanılmayan bir değişkene atayan veya geçersiz döndürmek için yöntem imzasını değiştiren çözümlerden özellikle hoşlanmıyorum. İlki gereksiz, sezgisel olmayan kod oluşturur, ikincisi ise bir arabirim uyguluyorsanız veya döndürülen Görevi kullanmak istediğinizde işlevi başka bir şekilde kullanıyorsanız mümkün olmayabilir.

Benim çözümüm, DoNotAwait () adında hiçbir şey yapmayan bir Task genişletme yöntemi oluşturmaktır. Bu, yalnızca tüm uyarıları, ReSharper'ı veya başka şekilde bastırmakla kalmaz, aynı zamanda kodu daha anlaşılır hale getirir ve kodunuzun gelecekteki bakımcılarına, aramanın gerçekten beklenmemesini istediğinizi belirtir.

Uzatma yöntemi:

public static class TaskExtensions
{
    public static void DoNotAwait(this Task task) { }
}

Kullanımı:

public static void DoStuff()
{
    GetNameAsync().DoNotAwait();
    MainWorkOfApplicationIDontWantBlocked();
}

Eklemek için düzenlendi: Bu, Jonathan Allen'ın, daha önce başlamamışsa, uzatma yönteminin göreve başlayacağı çözümüne benzer, ancak arayanın amacının tamamen açık olması için tek amaçlı işlevlere sahip olmayı tercih ederim.

async void KÖTÜDÜR!

1. Geçersizliği iade etmek ile bir Görevi iade etmek arasındaki fark nedir?
2. https://jaylee.org/archive/2012/07/08/c-sharp-async-tips-and-tricks-part-2-async-void.html

Önerdiğim şey, açıkça Taskanonim bir yöntemle çalıştırmanızdır ...

Örneğin

public static void DoStuff()
{
    Task.Run(async () => GetNameAsync());
    MainWorkOfApplicationIDontWantBlocked();
}

Ya da engellemesini istiyorsanız anonim yöntemi bekleyebilirsiniz.

public static void DoStuff()
{
    Task.Run(async () => await GetNameAsync());
    MainWorkOfApplicationThatWillBeBlocked();
}

Bununla birlikte, GetNameAsyncyönteminizin UI ile veya hatta UI bağlı herhangi bir şeyle etkileşime girmesi gerekiyorsa (WINRT / MVVM, size bakıyorum), o zaman biraz daha eğlenceli olur =)

Referansı şu şekilde UI dağıtıcısına iletmeniz gerekir ...

Task.Run(async () => await GetNameAsync(CoreApplication.MainView.CoreWindow.Dispatcher));

Ve sonra eşzamansız yönteminizde, dağıtıcının düşündüğü UI veya UI bağlı öğelerinizle etkileşime girmeniz gerekir ...

dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {  this.UserName = userName; });

Şu anda yaptığım şey bu:

SomeAyncFunction().RunConcurrently();

Nerede RunConcurrentlytanımlanır ...

 /// <summary> 
 /// Runs the Task in a concurrent thread without waiting for it to complete. This will start the task if it is not already running. 
 /// </summary> 
 /// <param name="task">The task to run.</param> 
 /// <remarks>This is usually used to avoid warning messages about not waiting for the task to complete.</remarks> 
 public static void RunConcurrently(this Task task) 
 { 
     if (task == null) 
         throw new ArgumentNullException("task", "task is null."); 

     if (task.Status == TaskStatus.Created) 
         task.Start(); 
 } 

https://github.com/docevaad/Anchor/blob/master/Tortuga.Anchor/Tortuga.Anchor.source/shared/TaskUtilities.cs

https://www.nuget.org/packages/Tortuga.Anchor/

Bu uyarı ile ilgili Microsoft makalesine göre, döndürülen görevi bir değişkene atayarak sorunu çözebilirsiniz. Aşağıda Microsoft örneğinde verilen kodun bir çevirisi bulunmaktadır:

    // To suppress the warning without awaiting, you can assign the 
    // returned task to a variable. The assignment doesn't change how
    // the program runs. However, the recommended practice is always to
    // await a call to an async method.
    // Replace Call #1 with the following line.
    Task delayTask = CalledMethodAsync(delay);

Bunu yapmanın ReSharper'da "Yerel değişken asla kullanılmaz" mesajıyla sonuçlanacağını unutmayın.

İşte basit bir çözüm.

public static class TasksExtensions
{
    public static void RunAndForget(this Task task)
    {
    }
}

Saygılarımızla

Gereksiz koda neden olan basitleştirilmiş örneğinizdir. Normalde, programın bir noktasında engelleme kaynağından getirilen verileri kullanmak istersiniz, bu nedenle verilere ulaşmanın mümkün olması için sonucu geri istersiniz.

Gerçekten programın geri kalanından tamamen izole edilmiş bir şeyiniz varsa, asenkron doğru yaklaşım olmaz. Bu görev için yeni bir iş parçacığı başlatmanız yeterli.

Sonucu gerçekten görmezden gelmek istiyor musun? herhangi bir beklenmedik istisnayı görmezden gelmek gibi?

Değilse şu soruya bir göz atmak isteyebilirsiniz: Ateş Et ve Unut yaklaşımı ,

Döndürmek için yöntem imzasını değiştirmek istemiyorsanız void(geri dönüş voidher zaman geçersiz olmalıdır ) , bunun gibi C # 7.0+ Atma özelliğini kullanabilirsiniz , bu bir değişkene atamaktan biraz daha iyidir (ve diğer birçok kaynak doğrulama araçları uyarıları):

public static void DoStuff()
{
    _ = GetNameAsync(); // we don't need the return value (suppresses warning)
    MainWorkOfApplicationIDontWantBlocked();
}