Wie rufe ich eine asynchrone Methode von einer synchronen Methode in C # auf?

Ich habe ein public async void Foo() Methode, die ich von der synchronen Methode aufrufen möchte. Bisher habe ich in der MSDN-Dokumentation nur gesehen, dass asynchrone Methoden über asynchrone Methoden aufgerufen werden, aber mein gesamtes Programm ist nicht mit asynchronen Methoden erstellt.

Ist das überhaupt möglich?

Hier ist ein Beispiel für den Aufruf dieser Methoden von einer asynchronen Methode: http://msdn.microsoft.com/en-us/library/hh300224(v=vs.110).aspx

Jetzt möchte ich diese asynchronen Methoden von Synchronisationsmethoden aus aufrufen.

Die asynchrone Programmierung "wächst" durch die Codebasis. Es wurde mit einem Zombie-Virus verglichen . Die beste Lösung ist, es wachsen zu lassen, aber manchmal ist das nicht möglich.

Ich habe einige Typen in meine Nito.AsyncEx- Bibliothek geschrieben, um mit einer teilweise asynchronen Codebasis umzugehen . Es gibt jedoch keine Lösung, die in jeder Situation funktioniert.

Lösung A.

Wenn Sie eine einfache asynchrone Methode haben, die nicht wieder mit ihrem Kontext synchronisiert werden muss, können Sie Folgendes verwenden Task.WaitAndUnwrapException:

var task = MyAsyncMethod();
var result = task.WaitAndUnwrapException();

Sie möchten nicht verwenden Task.Waitoder Task.Resultweil sie Ausnahmen einschließen AggregateException.

Diese Lösung ist nur geeignet, wenn MyAsyncMethodsie nicht mit ihrem Kontext synchronisiert wird. Mit anderen Worten, jedes awaitIn MyAsyncMethodsollte mit enden ConfigureAwait(false). Dies bedeutet, dass keine UI-Elemente aktualisiert oder auf den ASP.NET-Anforderungskontext zugegriffen werden kann.

Lösung B.

Wenn MyAsyncMethodeine Synchronisierung mit dem Kontext erforderlich ist, können Sie möglicherweise AsyncContext.RunTaskeinen verschachtelten Kontext bereitstellen:

var result = AsyncContext.RunTask(MyAsyncMethod).Result;

* Update 14.04.2014: In neueren Versionen der Bibliothek lautet die API wie folgt:

var result = AsyncContext.Run(MyAsyncMethod);

( Task.ResultIn diesem Beispiel ist es in Ordnung, da RunTaskes sich ausbreitetTask Ausnahmen).

Der Grund, den Sie möglicherweise AsyncContext.RunTaskanstelle von benötigen, Task.WaitAndUnwrapExceptionist eine ziemlich subtile Deadlock-Möglichkeit, die unter WinForms / WPF / SL / ASP.NET auftritt:

1. Eine synchrone Methode ruft eine asynchrone Methode auf und erhält a Task.
2. Die synchrone Methode wartet blockierend auf die Task.
3. Die asyncMethode verwendetawait ohne ConfigureAwait.
4. Das Taskkann in dieser Situation nicht abgeschlossen werden, da es erst abgeschlossen wird, wenn die asyncMethode abgeschlossen ist. Die asyncMethode kann nicht abgeschlossen werden, da versucht wird, die Fortsetzung auf die zu planenSynchronizationContext , und WinForms / WPF / SL / ASP.NET lässt die Fortsetzung nicht zu, da die synchrone Methode bereits in diesem Kontext ausgeführt wird.

Dies ist ein Grund, warum es eine gute Idee ist, so viel wie möglich ConfigureAwait(false)in jeder asyncMethode zu verwenden .

Lösung C.

AsyncContext.RunTaskfunktioniert nicht in jedem Szenario. Wenn die asyncMethode beispielsweise auf etwas wartet, für dessen Abschluss ein UI-Ereignis erforderlich ist, blockieren Sie auch mit dem verschachtelten Kontext. In diesem Fall können Sie die asyncMethode im Thread-Pool starten :

var task = Task.Run(async () => await MyAsyncMethod());
var result = task.WaitAndUnwrapException();

Diese Lösung erfordert jedoch eine MyAsyncMethod, die im Thread-Pool-Kontext funktioniert. Daher kann es keine UI-Elemente aktualisieren oder auf den ASP.NET-Anforderungskontext zugreifen. Und in diesem Fall können Sie auch hinzufügen , ConfigureAwait(false)um seine awaitAussagen und Lösung A. verwenden

Update, 01.05.2019: Die aktuellen "am wenigsten schlimmsten Praktiken" finden Sie in einem MSDN-Artikel hier .

Das Hinzufügen einer Lösung, die mein Problem endlich gelöst hat, spart hoffentlich jemandem Zeit.

Lesen Sie zuerst ein paar Artikel von Stephen Cleary :

• Async und Await
• Blockieren Sie keinen asynchronen Code

Von den "zwei Best Practices" in "Nicht auf asynchronem Code blockieren" hat die erste für mich nicht funktioniert und die zweite war nicht anwendbar (im Grunde genommen, wenn ich sie verwenden kann await!).

Hier ist meine Problemumgehung: Wickeln Sie den Anruf in einen Task.Run<>(async () => await FunctionAsync());und hoffentlich keinen Deadlock mehr.

Hier ist mein Code:

public class LogReader
{
    ILogger _logger;

    public LogReader(ILogger logger)
    {
        _logger = logger;
    }

    public LogEntity GetLog()
    {
        Task<LogEntity> task = Task.Run<LogEntity>(async () => await GetLogAsync());
        return task.Result;
    }

    public async Task<LogEntity> GetLogAsync()
    {
        var result = await _logger.GetAsync();
        // more code here...
        return result as LogEntity;
    }
}

Microsoft hat eine (interne) AsyncHelper-Klasse erstellt, um Async als Sync auszuführen. Die Quelle sieht aus wie:

internal static class AsyncHelper
{
    private static readonly TaskFactory _myTaskFactory = new 
      TaskFactory(CancellationToken.None, 
                  TaskCreationOptions.None, 
                  TaskContinuationOptions.None, 
                  TaskScheduler.Default);

    public static TResult RunSync<TResult>(Func<Task<TResult>> func)
    {
        return AsyncHelper._myTaskFactory
          .StartNew<Task<TResult>>(func)
          .Unwrap<TResult>()
          .GetAwaiter()
          .GetResult();
    }

    public static void RunSync(Func<Task> func)
    {
        AsyncHelper._myTaskFactory
          .StartNew<Task>(func)
          .Unwrap()
          .GetAwaiter()
          .GetResult();
    }
}

Die Microsoft.AspNet.Identity-Basisklassen verfügen nur über Async-Methoden. Um sie als Sync aufzurufen, gibt es Klassen mit Erweiterungsmethoden, die wie folgt aussehen (Beispielverwendung):

public static TUser FindById<TUser, TKey>(this UserManager<TUser, TKey> manager, TKey userId) where TUser : class, IUser<TKey> where TKey : IEquatable<TKey>
{
    if (manager == null)
    {
        throw new ArgumentNullException("manager");
    }
    return AsyncHelper.RunSync<TUser>(() => manager.FindByIdAsync(userId));
}

public static bool IsInRole<TUser, TKey>(this UserManager<TUser, TKey> manager, TKey userId, string role) where TUser : class, IUser<TKey> where TKey : IEquatable<TKey>
{
    if (manager == null)
    {
        throw new ArgumentNullException("manager");
    }
    return AsyncHelper.RunSync<bool>(() => manager.IsInRoleAsync(userId, role));
}

Für diejenigen, die sich Gedanken über die Lizenzierungsbedingungen für Code machen, ist hier ein Link zu sehr ähnlichem Code (fügt nur Unterstützung für die Kultur im Thread hinzu), der Kommentare enthält, die darauf hinweisen, dass es sich um eine von Microsoft lizenzierte MIT handelt. https://github.com/aspnet/AspNetIdentity/blob/master/src/Microsoft.AspNet.Identity.Core/AsyncHelper.cs

async Main ist jetzt Teil von C # 7.2 und kann in den erweiterten Build-Einstellungen des Projekts aktiviert werden.

Für C # <7.2 lautet der richtige Weg:

static void Main(string[] args)
{
   MainAsync().GetAwaiter().GetResult();
}


static async Task MainAsync()
{
   /*await stuff here*/
}

Sie werden dies in vielen Microsoft-Dokumentationen sehen, zum Beispiel: https://docs.microsoft.com/en-us/azure/service-bus-messaging/service-bus-dotnet-how-to-use- Themen-Abonnements

public async Task<string> StartMyTask()
{
    await Foo()
    // code to execute once foo is done
}

static void Main()
{
     var myTask = StartMyTask(); // call your method which will return control once it hits await
     // now you can continue executing code here
     string result = myTask.Result; // wait for the task to complete to continue
     // use result

}

Sie lesen das Schlüsselwort 'await' als "Diese lange laufende Aufgabe starten und dann die Steuerung an die aufrufende Methode zurückgeben". Sobald die lang laufende Aufgabe erledigt ist, führt sie den Code danach aus. Der Code nach dem Warten ähnelt den früheren CallBack-Methoden. Der große Unterschied besteht darin, dass der logische Ablauf nicht unterbrochen wird, was das Schreiben und Lesen erheblich erleichtert.

Ich bin nicht 100% sicher, aber ich glaube, dass die in diesem Blog beschriebene Technik unter vielen Umständen funktionieren sollte:

Sie können also verwenden, task.GetAwaiter().GetResult()wenn Sie diese Ausbreitungslogik direkt aufrufen möchten.

Es gibt jedoch eine gute Lösung, die in jeder Situation funktioniert (fast: siehe Kommentare): eine Ad-hoc-Nachrichtenpumpe (SynchronizationContext).

Der aufrufende Thread wird wie erwartet blockiert, wobei weiterhin sichergestellt wird, dass alle von der asynchronen Funktion aufgerufenen Fortsetzungen nicht blockieren, da sie für den Ad-hoc-SynchronizationContext (Nachrichtenpumpe) gemarshallt werden, der auf dem aufrufenden Thread ausgeführt wird.

Der Code des Ad-hoc-Nachrichtenpumpen-Helfers:

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace Microsoft.Threading
{
    /// <summary>Provides a pump that supports running asynchronous methods on the current thread.</summary>
    public static class AsyncPump
    {
        /// <summary>Runs the specified asynchronous method.</summary>
        /// <param name="asyncMethod">The asynchronous method to execute.</param>
        public static void Run(Action asyncMethod)
        {
            if (asyncMethod == null) throw new ArgumentNullException("asyncMethod");

            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(true);
                SynchronizationContext.SetSynchronizationContext(syncCtx);

                // Invoke the function
                syncCtx.OperationStarted();
                asyncMethod();
                syncCtx.OperationCompleted();

                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

        /// <summary>Runs the specified asynchronous method.</summary>
        /// <param name="asyncMethod">The asynchronous method to execute.</param>
        public static void Run(Func<Task> asyncMethod)
        {
            if (asyncMethod == null) throw new ArgumentNullException("asyncMethod");

            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(false);
                SynchronizationContext.SetSynchronizationContext(syncCtx);

                // Invoke the function and alert the context to when it completes
                var t = asyncMethod();
                if (t == null) throw new InvalidOperationException("No task provided.");
                t.ContinueWith(delegate { syncCtx.Complete(); }, TaskScheduler.Default);

                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
                t.GetAwaiter().GetResult();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

        /// <summary>Runs the specified asynchronous method.</summary>
        /// <param name="asyncMethod">The asynchronous method to execute.</param>
        public static T Run<T>(Func<Task<T>> asyncMethod)
        {
            if (asyncMethod == null) throw new ArgumentNullException("asyncMethod");

            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(false);
                SynchronizationContext.SetSynchronizationContext(syncCtx);

                // Invoke the function and alert the context to when it completes
                var t = asyncMethod();
                if (t == null) throw new InvalidOperationException("No task provided.");
                t.ContinueWith(delegate { syncCtx.Complete(); }, TaskScheduler.Default);

                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
                return t.GetAwaiter().GetResult();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

        /// <summary>Provides a SynchronizationContext that's single-threaded.</summary>
        private sealed class SingleThreadSynchronizationContext : SynchronizationContext
        {
            /// <summary>The queue of work items.</summary>
            private readonly BlockingCollection<KeyValuePair<SendOrPostCallback, object>> m_queue =
                new BlockingCollection<KeyValuePair<SendOrPostCallback, object>>();
            /// <summary>The processing thread.</summary>
            private readonly Thread m_thread = Thread.CurrentThread;
            /// <summary>The number of outstanding operations.</summary>
            private int m_operationCount = 0;
            /// <summary>Whether to track operations m_operationCount.</summary>
            private readonly bool m_trackOperations;

            /// <summary>Initializes the context.</summary>
            /// <param name="trackOperations">Whether to track operation count.</param>
            internal SingleThreadSynchronizationContext(bool trackOperations)
            {
                m_trackOperations = trackOperations;
            }

            /// <summary>Dispatches an asynchronous message to the synchronization context.</summary>
            /// <param name="d">The System.Threading.SendOrPostCallback delegate to call.</param>
            /// <param name="state">The object passed to the delegate.</param>
            public override void Post(SendOrPostCallback d, object state)
            {
                if (d == null) throw new ArgumentNullException("d");
                m_queue.Add(new KeyValuePair<SendOrPostCallback, object>(d, state));
            }

            /// <summary>Not supported.</summary>
            public override void Send(SendOrPostCallback d, object state)
            {
                throw new NotSupportedException("Synchronously sending is not supported.");
            }

            /// <summary>Runs an loop to process all queued work items.</summary>
            public void RunOnCurrentThread()
            {
                foreach (var workItem in m_queue.GetConsumingEnumerable())
                    workItem.Key(workItem.Value);
            }

            /// <summary>Notifies the context that no more work will arrive.</summary>
            public void Complete() { m_queue.CompleteAdding(); }

            /// <summary>Invoked when an async operation is started.</summary>
            public override void OperationStarted()
            {
                if (m_trackOperations)
                    Interlocked.Increment(ref m_operationCount);
            }

            /// <summary>Invoked when an async operation is completed.</summary>
            public override void OperationCompleted()
            {
                if (m_trackOperations &&
                    Interlocked.Decrement(ref m_operationCount) == 0)
                    Complete();
            }
        }
    }
}

Verwendungszweck:

AsyncPump.Run(() => FooAsync(...));

Eine detailliertere Beschreibung der Async-Pumpe finden Sie hier .

Für alle, die sich noch mehr mit dieser Frage beschäftigen ...

Wenn Sie hineinschauen, Microsoft.VisualStudio.Services.WebApigibt es eine Klasse namens TaskExtensions. Innerhalb dieser Klasse sehen Sie die statische Erweiterungsmethode Task.SyncResult(), die den Thread wie vollständig blockiert, bis die Aufgabe zurückkehrt.

Intern ruft es auf, task.GetAwaiter().GetResult()was ziemlich einfach ist, aber es ist überladen, an jeder asyncMethode zu arbeiten, die zurückkehrt Task, Task<T>oder Task<HttpResponseMessage>... syntaktischer Zucker, Baby ... Papa hat einen süßen Zahn.

Es sieht so aus, ...GetAwaiter().GetResult()als wäre dies die offizielle Methode von MS, um asynchronen Code in einem blockierenden Kontext auszuführen. Scheint für meinen Anwendungsfall sehr gut zu funktionieren.

var result = Task.Run(async () => await configManager.GetConfigurationAsync()).ConfigureAwait(false);

OpenIdConnectConfiguration config = result.GetAwaiter().GetResult();

Oder benutze dies:

var result=result.GetAwaiter().GetResult().AccessToken

Sie können jede asynchrone Methode aus synchronem Code aufrufen, dh bis Sie sie benötigen await. In diesem Fall müssen sie auch markiert asyncwerden.

Wie viele Leute hier vorschlagen, können Sie Wait () oder Result für die resultierende Aufgabe in Ihrer synchronen Methode aufrufen, aber dann erhalten Sie einen blockierenden Aufruf in dieser Methode, der den Zweck der Asynchronisierung zunichte macht.

Wenn Sie Ihre Methode wirklich nicht erstellen können asyncund die synchrone Methode nicht blockieren möchten, müssen Sie eine Rückrufmethode verwenden, indem Sie sie als Parameter an die ContinueWith-Methode für die Aufgabe übergeben.

Ich weiß, dass ich so spät bin. Aber für den Fall, dass jemand wie ich dies auf eine ordentliche, einfache Art und Weise lösen wollte, ohne von einer anderen Bibliothek abhängig zu sein.

Ich habe den folgenden Code von Ryan gefunden

public static class AsyncHelpers
{
    private static readonly TaskFactory taskFactory = new
        TaskFactory(CancellationToken.None,
            TaskCreationOptions.None,
            TaskContinuationOptions.None,
            TaskScheduler.Default);

    /// <summary>
    /// Executes an async Task method which has a void return value synchronously
    /// USAGE: AsyncUtil.RunSync(() => AsyncMethod());
    /// </summary>
    /// <param name="task">Task method to execute</param>
    public static void RunSync(Func<Task> task)
        => taskFactory
            .StartNew(task)
            .Unwrap()
            .GetAwaiter()
            .GetResult();

    /// <summary>
    /// Executes an async Task<T> method which has a T return type synchronously
    /// USAGE: T result = AsyncUtil.RunSync(() => AsyncMethod<T>());
    /// </summary>
    /// <typeparam name="TResult">Return Type</typeparam>
    /// <param name="task">Task<T> method to execute</param>
    /// <returns></returns>
    public static TResult RunSync<TResult>(Func<Task<TResult>> task)
        => taskFactory
            .StartNew(task)
            .Unwrap()
            .GetAwaiter()
            .GetResult();
}

dann kannst du es so nennen

var t = AsyncUtil.RunSync<T>(() => AsyncMethod<T>());

Nachdem ich stundenlang verschiedene Methoden ausprobiert hatte, mit mehr oder weniger Erfolg, endete ich damit. Es endet nicht in einem Deadlock, während das Ergebnis abgerufen wird, und es wird auch die ursprüngliche Ausnahme und nicht die umschlossene Ausnahme abgerufen und ausgelöst.

private ReturnType RunSync()
{
  var task = Task.Run(async () => await myMethodAsync(agency));
  if (task.IsFaulted && task.Exception != null)
  {
    throw task.Exception;
  }

  return task.Result;
}

Es könnte von einem neuen Thread aufgerufen werden (NICHT vom Thread-Pool!):

public static class SomeHelperClass
{ 
       public static T Result<T>(Func<T> func)
        {
            return Task.Factory.StartNew<T>(
                  () => func()
                , TaskCreationOptions.LongRunning
                ).Result;
        }
}
...
content = SomeHelperClass.Result<string>(
  () => response.Content.ReadAsStringAsync().Result
  );

Diese asynchronen Windows-Methoden haben eine raffinierte kleine Methode namens AsTask (). Sie können dies verwenden, damit sich die Methode selbst als Task zurückgibt, sodass Sie Wait () manuell aufrufen können.

In einer Windows Phone 8 Silverlight-Anwendung können Sie beispielsweise Folgendes tun:

private void DeleteSynchronous(string path)
{
    StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
    Task t = localFolder.DeleteAsync(StorageDeleteOption.PermanentDelete).AsTask();
    t.Wait();
}

private void FunctionThatNeedsToBeSynchronous()
{
    // Do some work here
    // ....

    // Delete something in storage synchronously
    DeleteSynchronous("pathGoesHere");

    // Do other work here 
    // .....
}

Hoffe das hilft!

Wenn Sie es ausführen möchten, synchronisieren Sie es

MethodAsync().RunSynchronously()

   //Example from non UI thread -    
   private void SaveAssetAsDraft()
    {
        SaveAssetDataAsDraft();
    }
    private async Task<bool> SaveAssetDataAsDraft()
    {
       var id = await _assetServiceManager.SavePendingAssetAsDraft();
       return true;   
    }
   //UI Thread - 
   var result = Task.Run(() => SaveAssetDataAsDraft().Result).Result;