Как вызвать асинхронный метод из синхронного метода в C #?

У меня есть public async void Foo()метод, который я хочу вызвать из синхронного метода. До сих пор все, что я видел из документации MSDN, это вызов асинхронных методов через асинхронные методы, но вся моя программа не построена с асинхронными методами.

Это вообще возможно?

Вот один пример вызова этих методов из асинхронного метода: http://msdn.microsoft.com/en-us/library/hh300224(v=vs.110).aspx

Теперь я смотрю на вызов этих асинхронных методов из методов синхронизации.

Асинхронное программирование «растет» через базу кода. Это было по сравнению с вирусом зомби . Лучшее решение - позволить ему расти, но иногда это невозможно.

Я написал несколько типов в моей библиотеке Nito.AsyncEx для работы с частично асинхронной базой кода. Там нет решения, которое работает в любой ситуации, хотя.

Решение А

Если у вас есть простой асинхронный метод, который не нуждается в синхронизации обратно в его контекст, то вы можете использовать Task.WaitAndUnwrapException:

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

Вы не хотите использовать Task.Waitили Task.Resultпотому что они обертывают исключения в AggregateException.

Это решение подходит только в том случае, если MyAsyncMethodне выполняется обратная синхронизация с его контекстом. Другими словами, каждый awaitв MyAsyncMethodдолжен заканчиваться ConfigureAwait(false). Это означает, что он не может обновлять какие-либо элементы пользовательского интерфейса или обращаться к контексту запроса ASP.NET.

Решение Б

Если MyAsyncMethodнеобходимо синхронизировать обратно с его контекстом, то вы можете использовать его AsyncContext.RunTaskдля предоставления вложенного контекста:

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

* Обновление от 14.04.2014: В более поздних версиях библиотеки API выглядит следующим образом:

var result = AsyncContext.Run(MyAsyncMethod);

(Можно использовать Task.Resultв этом примере, потому что RunTaskбудут распространяться Taskисключения).

Причина, по которой вам может понадобиться AsyncContext.RunTaskвместо этого, Task.WaitAndUnwrapExceptionзаключается в том, что в WinForms / WPF / SL / ASP.NET возможна довольно слабая тупиковая ситуация:

1. Синхронный метод вызывает асинхронный метод, получая Task.
2. Синхронный метод блокирует ожидание Task.
3. asyncМетод использует awaitбез ConfigureAwait.
4. TaskНе может завершить в этой ситуации , потому что завершается только тогда , когда asyncметод законченный; asyncметод не может завершить , потому что он пытается планировать свое продолжение к SynchronizationContextи WinForms / WPF / SL / ASP.NET не позволит запустить продолжение , так как синхронный метод уже работает в этом контексте.

Это одна из причин, почему стоит использовать как можно больше ConfigureAwait(false)внутри каждого asyncметода.

Решение С

AsyncContext.RunTaskне будет работать в каждом сценарии. Например, если asyncметод ожидает чего-то, что требует события пользовательского интерфейса для завершения, то вы зашли в тупик даже с вложенным контекстом. В этом случае вы можете запустить asyncметод в пуле потоков:

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

Однако это решение требует, MyAsyncMethodчтобы он работал в контексте пула потоков. Поэтому он не может обновлять элементы пользовательского интерфейса или обращаться к контексту запроса ASP.NET. И в этом случае вы можете также добавить ConfigureAwait(false)к его awaitзаявлениям и использовать решение А.

Обновление, 2019-05-01: Текущие «наихудшие практики» описаны в статье MSDN здесь .

Добавление решения, которое окончательно решило мою проблему, надеюсь, сэкономит чье-то время.

Сначала прочитайте пару статей Стивена Клири :

• Async и Await
• Не блокировать асинхронный код

Из «двух лучших практик» в «Не блокировать в асинхронном коде», первая не работала для меня, а вторая неприменима (в основном, если я могу использовать await, я делаю!).

Итак, вот мой обходной путь: оберните вызов внутри Task.Run<>(async () => await FunctionAsync());и, надеюсь, больше не тупик .

Вот мой код:

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 создала AsyncHelper (внутренний) класс для запуска Async как Sync. Источник выглядит так:

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

Базовые классы Microsoft.AspNet.Identity имеют только методы Async, и для вызова их как Sync существуют классы с методами расширения, которые выглядят следующим образом (пример использования):

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

Для тех, кто обеспокоен условиями лицензирования кода, здесь есть ссылка на очень похожий код (просто добавлена ​​поддержка культуры в потоке), в которой есть комментарии, указывающие, что это лицензия MIT от Microsoft. https://github.com/aspnet/AspNetIdentity/blob/master/src/Microsoft.AspNet.Identity.Core/AsyncHelper.cs

async Main теперь является частью C # 7.2 и может быть включен в расширенных настройках проекта.

Для C # <7.2 правильный путь:

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


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

Вы увидите, что это используется во многих документах Microsoft, например: https://docs.microsoft.com/en-us/azure/service-bus-messaging/service-bus-dotnet-how-to-use- Тем-подписка

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

}

Вы читаете ключевое слово «await» как «запустите эту долгосрочную задачу, а затем верните управление вызывающему методу». Как только долгосрочное задание выполнено, оно выполняет код после него. Код после await похож на то, что раньше было методами CallBack. Большая разница в том, что логический поток не прерывается, что делает его намного легче писать и читать.

Я не уверен на 100%, но я считаю, что методика, описанная в этом блоге, должна работать во многих случаях:

Таким образом, вы можете использовать, task.GetAwaiter().GetResult()если хотите напрямую вызывать эту логику распространения.

Однако есть хорошее решение, которое работает (почти: см. Комментарии) в любой ситуации: специальный механизм обработки сообщений (SynchronizationContext).

Вызывающий поток будет заблокирован, как и ожидалось, при этом гарантируя, что все продолжения, вызываемые из асинхронной функции, не будут взаимоблокированы, поскольку они будут перенаправлены в специальный SynchronizationContext (насос сообщений), работающий в вызывающем потоке.

Код специального помощника по отправке сообщений:

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

Применение:

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

Более подробное описание асинхронного насоса доступно здесь .

Всем, кто больше обращает внимание на этот вопрос ...

Если вы посмотрите, Microsoft.VisualStudio.Services.WebApiесть класс с именем TaskExtensions. В этом классе вы увидите статический метод расширенияTask.SyncResult() , который, как и полностью, просто блокирует поток до тех пор, пока задача не вернется.

Внутренне он вызывает task.GetAwaiter().GetResult()довольно просто, но перегружен для работы с любым asyncвозвращаемым методом Task, Task<T>илиTask<HttpResponseMessage> ... синтаксический сахар, ребенок ... папа получил сладкий зуб.

Похоже, ...GetAwaiter().GetResult()это официальный MS-способ выполнения асинхронного кода в контексте блокировки. Кажется, работает очень хорошо для моего случая использования.

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

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

Или используйте это:

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

Вы можете вызывать любой асинхронный метод из синхронного кода, то есть до тех пор, пока он вам не понадобится await, и в этом случае они также должны быть отмечены async.

Как многие здесь предлагают, вы можете вызвать Wait () или Result для результирующей задачи в вашем синхронном методе, но затем вы получите блокирующий вызов в этом методе, что побеждает асинхронную цель.

Если вы действительно не можете создать свой метод asyncи не хотите блокировать синхронный метод, тогда вам придется использовать метод обратного вызова, передав его в качестве параметра методу ContinueWith в задаче.

Я знаю, что так поздно. Но в случае, если кто-то, как я, хотел бы решить это аккуратно, легко и без зависимости от другой библиотеки.

Я нашел следующий кусок кода от Райана

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

тогда вы можете назвать это так

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

После нескольких часов проб разных методов, с более или менее успешным завершением, на этом я и закончил. Он не заканчивается тупиком при получении результата, а также получает и выдает исходное исключение, а не завернутое.

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

  return task.Result;
}

Он может быть вызван из нового потока (НЕ из пула потоков!):

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

Эти асинхронные методы Windows имеют изящный маленький метод, называемый AsTask (). Вы можете использовать это, чтобы метод возвращал себя в качестве задачи, чтобы вы могли вручную вызывать Wait () для него.

Например, в приложении Windows Phone 8 Silverlight вы можете сделать следующее:

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 
    // .....
}

Надеюсь это поможет!

Если вы хотите запустить его Sync

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;