Làm cách nào để gọi phương thức không đồng bộ từ phương thức đồng bộ trong C #?

Tôi có một public async void Foo()phương thức mà tôi muốn gọi từ phương thức đồng bộ. Cho đến nay tất cả những gì tôi thấy từ tài liệu MSDN đang gọi các phương thức async thông qua các phương thức async, nhưng toàn bộ chương trình của tôi không được xây dựng bằng các phương thức async.

Điều này thậm chí có thể?

Đây là một ví dụ về cách gọi các phương thức này từ một phương thức không đồng bộ: http://msdn.microsoft.com/en-us/l Library / hh300224 (v = vs.110) .aspx

Bây giờ tôi đang xem xét việc gọi các phương thức không đồng bộ này từ các phương thức đồng bộ hóa.

Lập trình không đồng bộ "phát triển" thông qua cơ sở mã. Nó đã được so sánh với một virus zombie . Giải pháp tốt nhất là cho phép nó phát triển, nhưng đôi khi điều đó là không thể.

Tôi đã viết một vài loại trong thư viện Nito.AsyncEx của mình để xử lý cơ sở mã không đồng bộ một phần. Không có giải pháp nào hoạt động trong mọi tình huống.

Giải pháp A

Nếu bạn có một phương pháp không đồng bộ đơn giản mà không cần đồng bộ hóa trở lại bối cảnh của nó, thì bạn có thể sử dụng Task.WaitAndUnwrapException:

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

Bạn không muốn sử dụng Task.Waithoặc Task.Resultvì chúng bao gồm các ngoại lệ AggregateException.

Giải pháp này chỉ phù hợp nếu MyAsyncMethodkhông đồng bộ hóa trở lại bối cảnh của nó. Nói cách khác, mỗi awaittrong MyAsyncMethodnên kết thúc bằng ConfigureAwait(false). Điều này có nghĩa là nó không thể cập nhật bất kỳ thành phần UI nào hoặc truy cập vào bối cảnh yêu cầu ASP.NET.

Giải pháp B

Nếu MyAsyncMethodkhông cần phải đồng bộ hóa trở lại bối cảnh của nó, thì bạn có thể sử dụng AsyncContext.RunTaskđể cung cấp một bối cảnh lồng nhau:

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

* Cập nhật ngày 14 tháng 4 năm 2014: Trong các phiên bản gần đây hơn của thư viện, API như sau:

var result = AsyncContext.Run(MyAsyncMethod);

(Bạn có thể sử dụng Task.Resulttrong ví dụ này vì RunTasksẽ truyền Taskngoại lệ).

Lý do bạn có thể cần AsyncContext.RunTaskthay vì Task.WaitAndUnwrapExceptionlà vì khả năng bế tắc khá tinh tế xảy ra trên WinForms / WPF / SL / ASP.NET:

1. Phương thức đồng bộ gọi phương thức không đồng bộ, thu được a Task.
2. Phương thức đồng bộ thực hiện chờ chặn trên Task.
3. Các asyncphương pháp sử dụng awaitmà không cần ConfigureAwait.
4. Không Taskthể hoàn thành trong tình huống này vì nó chỉ hoàn thành khi asyncphương thức kết thúc; các asyncphương pháp có thể không đầy đủ vì nó đang cố gắng sắp xếp tiếp nối của nó đến SynchronizationContext, và WinForms / WPF / SL / ASP.NET sẽ không cho phép việc tiếp tục chạy vì phương pháp đồng bộ vẫn đang chạy trong bối cảnh đó.

Đây là một lý do tại sao nên sử dụng ConfigureAwait(false)trong mọi asyncphương pháp càng nhiều càng tốt.

Giải pháp C

AsyncContext.RunTasksẽ không hoạt động trong mọi kịch bản. Ví dụ: nếu asyncphương thức chờ một cái gì đó yêu cầu sự kiện UI hoàn thành, thì bạn sẽ bế tắc ngay cả với bối cảnh lồng nhau. Trong trường hợp đó, bạn có thể bắt đầu asyncphương thức trên nhóm luồng:

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

Tuy nhiên, giải pháp này đòi hỏi một MyAsyncMethodthứ sẽ hoạt động trong bối cảnh nhóm luồng. Vì vậy, nó không thể cập nhật các thành phần UI hoặc truy cập vào bối cảnh yêu cầu ASP.NET. Và trong trường hợp đó, bạn cũng có thể thêm ConfigureAwait(false)vào các awaitcâu lệnh của nó và sử dụng giải pháp A.

Cập nhật, 2019-05-01: "Các thực tiễn tồi tệ nhất" hiện tại có trong một bài viết MSDN tại đây .

Thêm một giải pháp cuối cùng đã giải quyết vấn đề của tôi, hy vọng tiết kiệm thời gian của ai đó.

Đầu tiên đọc một vài bài viết của Stephen Cleary :

• Không đồng bộ và chờ đợi
• Không chặn mã Async

Từ "hai thực tiễn tốt nhất" trong "Không chặn mã Async", cách thứ nhất không hiệu quả với tôi và cách thứ hai không áp dụng (về cơ bản nếu tôi có thể sử dụng await, tôi sẽ làm!).

Vì vậy, đây là cách giải quyết của tôi: bọc cuộc gọi bên trong a Task.Run<>(async () => await FunctionAsync());và hy vọng không còn bế tắc nữa.

Đây là mã của tôi:

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 đã xây dựng một lớp AsyncHelper (nội bộ) để chạy Async như Sync. Nguồn trông như:

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

Các lớp cơ sở Microsoft.AspNet.Identity chỉ có các phương thức Async và để gọi chúng là Sync, có các lớp với các phương thức mở rộng trông giống như (sử dụng ví dụ):

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

Đối với những người quan tâm về các điều khoản cấp phép của mã, đây là một liên kết đến mã rất giống nhau (chỉ cần thêm hỗ trợ cho văn hóa trên luồng) có ý kiến ​​để chỉ ra rằng đó là MIT được cấp phép bởi Microsoft. https://github.com/aspnet/AspNetIdentity/blob/master/src/Microsoft.AspNet.Identity.Core/AsyncHelper.cs

async Main hiện là một phần của C # 7.2 và có thể được bật trong cài đặt bản dựng nâng cao của dự án.

Đối với C # <7.2, cách chính xác là:

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


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

Bạn sẽ thấy điều này được sử dụng trong rất nhiều tài liệu của Microsoft, ví dụ: https://docs.microsoft.com/en-us/azure/service-bus-messaging/service-bus-dotnet-how-to-use- đăng ký chủ đề

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

}

Bạn đọc từ khóa 'await' là "bắt đầu tác vụ dài này, sau đó trả lại quyền điều khiển cho phương thức gọi". Khi tác vụ chạy dài được thực hiện, nó sẽ thực thi mã sau nó. Mã sau khi chờ đợi tương tự như mã được sử dụng là phương thức CallBack. Sự khác biệt lớn là luồng logic không bị gián đoạn, giúp viết và đọc dễ dàng hơn nhiều.

Tôi không chắc chắn 100%, nhưng tôi tin rằng kỹ thuật được mô tả trong blog này sẽ hoạt động trong nhiều trường hợp:

Do đó, bạn có thể sử dụng task.GetAwaiter().GetResult()nếu bạn muốn trực tiếp gọi logic lan truyền này.

Tuy nhiên, có một giải pháp tốt hoạt động trong (hầu hết: xem bình luận) mọi tình huống: một máy bơm thông báo đặc biệt (SyncizationContext).

Chuỗi cuộc gọi sẽ bị chặn như mong đợi, trong khi vẫn đảm bảo rằng tất cả các liên tục được gọi từ chức năng async không bị bế tắc vì chúng sẽ được sắp xếp thành Đồng bộ hóa quảng cáo (bơm thông báo) đang chạy trên chuỗi cuộc gọi.

Mã của trình trợ giúp bơm tin nhắn ad-hoc:

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

Sử dụng:

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

Mô tả chi tiết hơn về bơm async có sẵn ở đây .

Để bất cứ ai chú ý đến câu hỏi này nữa ...

Nếu bạn nhìn vào Microsoft.VisualStudio.Services.WebApicó một lớp được gọi TaskExtensions. Trong lớp đó, bạn sẽ thấy phương thức mở rộng tĩnhTask.SyncResult() , giống như hoàn toàn chỉ chặn luồng cho đến khi tác vụ trở lại.

Trong nội bộ, nó gọi task.GetAwaiter().GetResult()là khá đơn giản, tuy nhiên, nó quá tải để làm việc trên bất kỳ asyncphương pháp nào quay trở lại Task, Task<T>hoặc Task<HttpResponseMessage>... đường cú pháp, em bé ... cha có một chiếc răng ngọt ngào.

Có vẻ như ...GetAwaiter().GetResult()là cách chính thức của MS để thực thi mã async trong ngữ cảnh chặn. Có vẻ để làm việc rất tốt cho trường hợp sử dụng của tôi.

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

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

Hoặc sử dụng cái này:

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

Bạn có thể gọi bất kỳ phương thức không đồng bộ nào từ mã đồng bộ, nghĩa là, cho đến khi bạn cần awaitbật chúng, trong trường hợp đó chúng cũng phải được đánh dấu async.

Như nhiều người đang đề xuất ở đây, bạn có thể gọi Wait () hoặc Kết quả về tác vụ kết quả trong phương thức đồng bộ của bạn, nhưng sau đó bạn kết thúc bằng một cuộc gọi chặn trong phương thức đó, loại này đánh bại mục đích của async.

Tôi thực sự không thể thực hiện phương thức của mình asyncvà bạn không muốn khóa phương thức đồng bộ, sau đó bạn sẽ phải sử dụng phương thức gọi lại bằng cách chuyển nó làm tham số cho phương thức ContinWith trong nhiệm vụ.

Tôi biết tôi đến muộn. Nhưng trong trường hợp ai đó như tôi muốn giải quyết vấn đề này một cách gọn gàng, dễ dàng và không phụ thuộc vào thư viện khác.

Tôi tìm thấy đoạn mã sau từ Ryan

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

sau đó bạn có thể gọi nó như thế này

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

Sau nhiều giờ thử các phương pháp khác nhau, với ít nhiều thành công, đây là những gì tôi đã kết thúc. Nó không kết thúc trong bế tắc trong khi nhận được kết quả và nó cũng nhận và ném ngoại lệ ban đầu và không phải là ngoại lệ.

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

  return task.Result;
}

Nó có thể được gọi từ một luồng mới (KHÔNG phải từ nhóm luồng!):

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

Các phương thức async của windows này có một phương thức nhỏ tiện lợi gọi là AsTask (). Bạn có thể sử dụng điều này để có phương thức tự trả về như một tác vụ để bạn có thể gọi Wait () theo cách thủ công trên nó.

Ví dụ: trên ứng dụng Windows Phone 8 Silverlight, bạn có thể thực hiện các thao tác sau:

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

Hi vọng điêu nay co ich!

Nếu bạn muốn chạy nó Đồng bộ hóa

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;