asyncHiçbir veri döndüren bir yöntem var :

public async Task MyAsyncMethod()
{
    // do some stuff async, don't return any data
}

Bu bazı veri döndürür başka bir yöntemden çağırıyorum:

public string GetStringData()
{
    MyAsyncMethod(); // this generates a warning and swallows exceptions
    return "hello world";
}

Arayan MyAsyncMethod()bir "neden beklemeden bu çağrı beklenen olmadığı için, geçerli yöntem çağrısı tamamlanmadan önce çalışmaya devam görsel stüdyoda uyarı". Bu uyarının sayfasında şunu belirtir:

Uyarıyı, yalnızca eşzamansız çağrının tamamlanmasını beklemek istemediğinizden ve çağrılan yöntemin herhangi bir istisna getirmeyeceğinden eminseniz bastırmayı düşünmelisiniz .

Eminim aramanın tamamlanmasını beklemek istemiyorum; Zamana ihtiyacım yok ya da vaktim yok. Ancak çağrı istisnalar doğurabilir .

Bu sorunu birkaç kez tökezledim ve bunun ortak bir çözümü olması gereken yaygın bir sorun olduğuna eminim.

Sonucu beklemeden nasıl async yöntemini güvenle arayabilirim?

Güncelleme:

Sonucu beklediğimi öne süren insanlar için bu, web servisimizdeki (ASP.NET Web API) bir web isteğine yanıt veren koddur. Bir UI bağlamında beklemek UI iş parçacığını serbest tutar, ancak bir web isteği çağrısında beklemek, göreve yanıt vermeden önce Görev'in bitmesini bekler ve böylece yanıt sürelerini hiçbir sebep olmadan arttırır.

İstisnayı "eşzamansız olarak" almak istiyorsanız, şunları yapabilirsiniz:

  MyAsyncMethod().
    ContinueWith(t => Console.WriteLine(t.Exception),
        TaskContinuationOptions.OnlyOnFaulted);

Bu, "ana" iş parçacığı dışındaki bir iş parçacığındaki bir özel durumla başa çıkmanıza olanak tanır. Bu MyAsyncMethod(), çağıran evrenden çağrı beklemek zorunda kalmayacağınız anlamına gelirMyAsyncMethod ; ancak yine de bir istisna dışında bir şey yapmanıza izin verir - ancak bir istisna oluşursa.

Güncelleme:

teknik olarak aşağıdakilere benzer bir şey yapabilirsiniz await:

try
{
    await MyAsyncMethod().ConfigureAwait(false);
}
catch (Exception ex)
{
    Trace.WriteLine(ex);
}

... özellikle try/ catch(veya using) kullanmanız gerektiğinde yararlı olabilir, ancak ContinueWithbunun ne ConfigureAwait(false)anlama geldiğini bilmek zorunda olduğunuz için biraz daha açık olduğunu düşünüyorum .

Öncelikle GetStringDatabir asyncyöntem yapmayı düşünmeli awaitve görevin geri döndürülmesini sağlamalısınız MyAsyncMethod.

İstisnaları ele almanızın MyAsyncMethod veya ne zaman tamamlandığını bilmeniz gerekmediğinden kesinlikle eminseniz, bunu yapabilirsiniz :

public string GetStringData()
{
  var _ = MyAsyncMethod();
  return "hello world";
}

BTW, bu bir "ortak sorun" değil. Bazı kod icra edilmesini isteyen çok nadirdir ve tamamlar umrumda değil ve başarıyla tamamlanıp tamamlanmadığını umursamak .

Güncelleme:

ASP.NET'te olduğunuz ve erken dönmek istediğiniz için konuyla ilgili blog yayınımı yararlı bulabilirsiniz . Ancak, ASP.NET bunun için tasarlanmamıştır ve garanti yoktur ve yanıt döndükten sonra kodunuzun çalışacağının . ASP.NET çalışmasına izin vermek için elinden geleni yapacaktır, ancak bunu garanti edemez.

Yani, bir olayı bir günlüğe atmak gibi basit bir şey için iyi bir çözümdür, burada burada birkaçını kaybederseniz gerçekten önemli değildir . İş açısından kritik her türlü işlem için iyi bir çözüm değildir. Bu durumlarda, işlemleri kaydetmek için kalıcı bir yolla (örneğin, Azure Kuyrukları, MSMQ) ve bunları işlemek için ayrı bir arka plan işlemiyle (örneğin, Azure Çalışan Rolü, Win32 Hizmeti) daha karmaşık bir mimari benimsemeniz gerekir .

Peter Ritchie'nin cevabı istediğim şeydi ve Stephen Cleary'nin ASP.NET'te erken dönme hakkındaki makalesi çok yardımcı oldu.

Ancak daha genel bir sorun olarak (ASP.NET içeriğine özgü değildir) aşağıdaki Konsol uygulaması, Peter'ın yanıtını kullanma ve davranışını gösterir Task.ContinueWith(...)

static void Main(string[] args)
{
  try
  {
    // output "hello world" as method returns early
    Console.WriteLine(GetStringData());
  }
  catch
  {
    // Exception is NOT caught here
  }
  Console.ReadLine();
}

public static string GetStringData()
{
  MyAsyncMethod().ContinueWith(OnMyAsyncMethodFailed, TaskContinuationOptions.OnlyOnFaulted);
  return "hello world";
}

public static async Task MyAsyncMethod()
{
  await Task.Run(() => { throw new Exception("thrown on background thread"); });
}

public static void OnMyAsyncMethodFailed(Task task)
{
  Exception ex = task.Exception;
  // Deal with exceptions here however you want
}

GetStringData()Erken beklemeden döner MyAsyncMethod()atılmış ve istisnalar MyAsyncMethod()ele alınmaktadır OnMyAsyncMethodFailed(Task task)ve değil de try/ catchçevresindeGetStringData()

Sonunda bu çözüm ile:

public async Task MyAsyncMethod()
{
    // do some stuff async, don't return any data
}

public string GetStringData()
{
    // Run async, no warning, exception are catched
    RunAsync(MyAsyncMethod()); 
    return "hello world";
}

private void RunAsync(Task task)
{
    task.ContinueWith(t =>
    {
        ILog log = ServiceLocator.Current.GetInstance<ILog>();
        log.Error("Unexpected Error", t.Exception);

    }, TaskContinuationOptions.OnlyOnFaulted);
}

Buna ateş ve unut denir ve bunun bir uzantısı vardır.

Bir görevi tüketir ve onunla hiçbir şey yapmaz. Zaman uyumsuz yöntemler içinde zaman uyumsuz yöntemlere ateş ve unut çağrıları için kullanışlıdır.

Nuget paketini kurun .

kullanın:

MyAsyncMethod().Forget();

Sanırım soru ortaya çıkıyor, bunu neden yapmanız gerekiyor? asyncC # 5.0'ın nedeni, bir sonuç beklemenizdir. Bu yöntem aslında eşzamansız değildir, sadece geçerli iş parçacığına çok fazla müdahale etmemek için bir seferde çağrılır.

Belki bir iplik başlatmak ve kendi başına bitirmek için bırakmak daha iyi olabilir.

İleti döngülerine sahip teknolojilerde (ASP bunlardan biri olup olmadığından emin değilsiniz), görev bitene kadar döngüyü engelleyebilir ve iletileri işleyebilir ve kodun engelini kaldırmak için ContinueWith'i kullanabilirsiniz:

public void WaitForTask(Task task)
{
    DispatcherFrame frame = new DispatcherFrame();
    task.ContinueWith(t => frame.Continue = false));
    Dispatcher.PushFrame(frame);
}

Bu yaklaşım ShowDialog'u engellemeye ve hala kullanıcı arayüzünü duyarlı tutmaya benzer.

Burada partiye geç kaldım, ama diğer cevaplarda referans olarak görmediğim harika bir kütüphane var

https://github.com/brminnick/AsyncAwaitBestPractices

"Ateş Et ve Unut" gerekiyorsa görevdeki uzantı yöntemini çağırırsınız.

İstisna eylemini çağrıya geçirmek, her iki dünyanın en iyisini elde etmenizi sağlar - istisnayı zarif bir şekilde ele alma yeteneğini korurken, yürütmeyi beklemenize ve kullanıcılarınızı yavaşlatmanıza gerek yoktur.

Örneğinizde şu şekilde kullanabilirsiniz:

   public string GetStringData()
    {
        MyAsyncMethod().SafeFireAndForget(onException: (exception) =>
                    {
                      //DO STUFF WITH THE EXCEPTION                    
                    }); 
        return "hello world";
    }

Ayrıca MVVM Xamarin çözümüm için harika olan ICommand'ı uygulayan beklenen AsyncCommands veriyor

Çözüm, HttpClient'i sincronizasyon bağlamı olmadan başka bir yürütme görevine başlatmaktır:

var submit = httpClient.PostAsync(uri, new StringContent(body, Encoding.UTF8,"application/json"));
var t = Task.Run(() => submit.ConfigureAwait(false));
await t.ConfigureAwait(false);

Bunu gerçekten yapmak istiyorsan. Sadece "beklemeden C # içinde bir zaman uyumsuz yöntemi çağırmak" adreslemek için, içinde zaman uyumsuz yöntemi çalıştırabilirsiniz Task.Run. Bu yaklaşım bitene kadar bekleyecek MyAsyncMethod.

public string GetStringData()
{
    Task.Run(()=> MyAsyncMethod()).Result;
    return "hello world";
}

awaitResultgörevinizin zaman uyumsuz olarak açılmasını sağlarken, yalnızca Sonucu kullanmak görev tamamlanıncaya kadar engellenir.

Genellikle async yöntemi Task sınıfını döndürür. Eğer kullanırsanız Wait()yöntem veya Resultözellik ve kod istisna atar - istisna tipi içine sarılmış olur AggregateException- o zaman sorguya gerekException.InnerException doğru istisna bulmak için.

Ama aynı zamanda kullanmak da mümkün .GetAwaiter().GetResult() yerine - aynı zamanda zaman uyumsuz görev bekler, ancak istisna sarmaz.

İşte kısa bir örnek:

public async Task MyMethodAsync()
{
}

public string GetStringData()
{
    MyMethodAsync().GetAwaiter().GetResult();
    return "test";
}

Ayrıca, async işlevinden bazı parametreler döndürmek isteyebilirsiniz - bu, Action<return type>örneğin async işlevine ekstra sağlayarak elde edilebilir , örneğin:

public string GetStringData()
{
    return MyMethodWithReturnParameterAsync().GetAwaiter().GetResult();
}

public async Task<String> MyMethodWithReturnParameterAsync()
{
    return "test";
}

Eşzamansız yöntemlerin ASync, yalnızca aynı ada sahip eşitleme işlevleri arasında çarpışmayı önlemek için, genellikle sonek adlarının bulunduğunu lütfen unutmayın . (Örn. FileStream.ReadAsync) - Bu öneriye uymak için işlev adlarını güncelledim.