C＃で同期メソッドから非同期メソッドを呼び出す方法は？

私が持っているpublic async void Foo()私は、同期メソッドから呼び出したいというメソッドを。これまでのところ、MSDNドキュメントから見たのは、非同期メソッドを介して非同期メソッドを呼び出すことだけですが、プログラム全体が非同期メソッドで構築されていません。

これは可能ですか？

以下は、非同期メソッドからこれらのメソッドを呼び出す1つの例です。http：//msdn.microsoft.com/en-us/library/hh300224（v = vs.110）.aspx

今、私はこれらの非同期メソッドを同期メソッドから呼び出すことを検討しています。

非同期プログラミングは、コードベースを通じて「成長」します。ゾンビウイルスと比較されています。最善の解決策は、それを成長させることですが、それができない場合もあります。

部分的に非同期のコードベースを処理するために、Nito.AsyncExライブラリにいくつかの型を記述しました。ただし、すべての状況で機能する解決策はありません。

ソリューションA

コンテキストに同期する必要のない単純な非同期メソッドがある場合は、次を使用できますTask.WaitAndUnwrapException。

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

あなたはないではない使用したいTask.Waitか、Task.Result彼らは例外をラップしているためAggregateException。

このソリューションは、MyAsyncMethodがそのコンテキストに同期しない場合にのみ適切です。つまり、すべての入力awaitはMyAsyncMethodで終わる必要がありConfigureAwait(false)ます。つまり、UI要素を更新したり、ASP.NET要求コンテキストにアクセスしたりすることはできません。

ソリューションB

MyAsyncMethodコンテキストに同期する必要がある場合はAsyncContext.RunTask、ネストされたコンテキストを提供するために使用できる場合があります。

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

* 2014年4月14日更新：ライブラリの最新バージョンでは、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メソッド内で可能な限り使用することが推奨される理由の1つです。

ソリューションC

AsyncContext.RunTaskすべてのシナリオで機能するわけではありません。たとえば、asyncメソッドがUIイベントの完了を必要とする何かを待機している場合、ネストされたコンテキストでもデッドロックが発生します。その場合、asyncスレッドプールでメソッドを開始できます。

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

ただし、このソリューションではMyAsyncMethod、スレッドプールコンテキストで機能するが必要です。したがって、UI要素を更新したり、ASP.NET要求コンテキストにアクセスしたりすることはできません。その場合は、ConfigureAwait(false)そのawaitステートメントに追加して、ソリューションAを使用することもできます。

更新、2019-05-01：現在の「最悪の慣行」は、こちらのMSDN記事にあります。

最終的に私の問題を解決したソリューションを追加すると、誰かの時間を節約できると思います。

まず、Stephen Clearyの記事をいくつか読んでください。

• 非同期および待機
• 非同期コードをブロックしない

「非同期コードでブロックしない」の「2つのベストプラクティス」によると、最初の方法は機能せず、2番目の方法は適用できませんでした（基本的に、を使用できる場合は使用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は、AsyncをSyncとして実行するためのAsyncHelper（内部）クラスを作成しました。ソースは次のようになります。

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ライセンスされていることを示すコメントがあります。 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」キーワードを「この長時間実行タスクを開始してから、制御を呼び出しメソッドに戻す」と読みます。実行時間の長いタスクが完了すると、その後にコードが実行されます。待機後のコードは、以前は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、return 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
  );

これらのウィンドウ非同期メソッドには、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 
    // .....
}

お役に立てれば！

同期したい場合

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;