Làm cách nào để tôi chạy phương thức async Nhiệm vụ <T> một cách đồng bộ?

Tôi đang tìm hiểu về async / await, và gặp phải tình huống tôi cần gọi một phương thức async một cách đồng bộ. Làm thế nào tôi có thể làm điều đó?

Phương pháp không đồng bộ:

public async Task<Customers> GetCustomers()
{
    return await Service.GetCustomersAsync();
}

Sử dụng bình thường:

public async void GetCustomers()
{
    customerList = await GetCustomers();
}

Tôi đã thử sử dụng như sau:

Task<Customer> task = GetCustomers();
task.Wait()

Task<Customer> task = GetCustomers();
task.RunSynchronously();

Task<Customer> task = GetCustomers();
while(task.Status != TaskStatus.RanToCompletion)

Tôi cũng đã thử một đề nghị từ đây , tuy nhiên nó không hoạt động khi người điều phối ở trạng thái lơ lửng.

public static void WaitWithPumping(this Task task) 
{
        if (task == null) throw new ArgumentNullException(“task”);
        var nestedFrame = new DispatcherFrame();
        task.ContinueWith(_ => nestedFrame.Continue = false);
        Dispatcher.PushFrame(nestedFrame);
        task.Wait();
}

Đây là trường hợp ngoại lệ và ngăn xếp từ cuộc gọi RunSynchronously:

System.InvalidOperationException

Thông báo : RunSyn đồng bộ có thể không được gọi trong một nhiệm vụ không gắn kết với một đại biểu.

Nội bộ ngoại lệ : null

Nguồn : mscorlib

StackTrace :

          at System.Threading.Tasks.Task.InternalRunSynchronously(TaskScheduler scheduler)
   at System.Threading.Tasks.Task.RunSynchronously()
   at MyApplication.CustomControls.Controls.MyCustomControl.CreateAvailablePanelList() in C:\Documents and Settings\...\MyApplication.CustomControls\Controls\MyCustomControl.xaml.cs:line 638
   at MyApplication.CustomControls.Controls.MyCustomControl.get_AvailablePanels() in C:\Documents and Settings\...\MyApplication.CustomControls\Controls\MyCustomControl.xaml.cs:line 233
   at MyApplication.CustomControls.Controls.MyCustomControl.<CreateOpenPanelList>b__36(DesktopPanel panel) in C:\Documents and Settings\...\MyApplication.CustomControls\Controls\MyCustomControl.xaml.cs:line 597
   at System.Collections.Generic.List`1.ForEach(Action`1 action)
   at MyApplication.CustomControls.Controls.MyCustomControl.<CreateOpenPanelList>d__3b.MoveNext() in C:\Documents and Settings\...\MyApplication.CustomControls\Controls\MyCustomControl.xaml.cs:line 625
   at System.Runtime.CompilerServices.TaskAwaiter.<>c__DisplayClass7.<TrySetContinuationForAwait>b__1(Object state)
   at System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs)
   at MS.Internal.Threading.ExceptionFilterHelper.TryCatchWhen(Object source, Delegate method, Object args, Int32 numArgs, Delegate catchHandler)
   at System.Windows.Threading.DispatcherOperation.InvokeImpl()
   at System.Windows.Threading.DispatcherOperation.InvokeInSecurityContext(Object state)
   at System.Threading.ExecutionContext.runTryCode(Object userData)
   at System.Runtime.CompilerServices.RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(TryCode code, CleanupCode backoutCode, Object userData)
   at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean ignoreSyncCtx)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Windows.Threading.DispatcherOperation.Invoke()
   at System.Windows.Threading.Dispatcher.ProcessQueue()
   at System.Windows.Threading.Dispatcher.WndProcHook(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, Boolean& handled)
   at MS.Win32.HwndWrapper.WndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, Boolean& handled)
   at MS.Win32.HwndSubclass.DispatcherCallbackOperation(Object o)
   at System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs)
   at MS.Internal.Threading.ExceptionFilterHelper.TryCatchWhen(Object source, Delegate method, Object args, Int32 numArgs, Delegate catchHandler)
   at System.Windows.Threading.Dispatcher.InvokeImpl(DispatcherPriority priority, TimeSpan timeout, Delegate method, Object args, Int32 numArgs)
   at MS.Win32.HwndSubclass.SubclassWndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam)
   at MS.Win32.UnsafeNativeMethods.DispatchMessage(MSG& msg)
   at System.Windows.Threading.Dispatcher.PushFrameImpl(DispatcherFrame frame)
   at System.Windows.Threading.Dispatcher.PushFrame(DispatcherFrame frame)
   at System.Windows.Threading.Dispatcher.Run()
   at System.Windows.Application.RunDispatcher(Object ignore)
   at System.Windows.Application.RunInternal(Window window)
   at System.Windows.Application.Run(Window window)
   at System.Windows.Application.Run()
   at MyApplication.App.Main() in C:\Documents and Settings\...\MyApplication\obj\Debug\App.g.cs:line 50
   at System.AppDomain._nExecuteAssembly(RuntimeAssembly assembly, String[] args)
   at System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args)
   at Microsoft.VisualStudio.HostingProcess.HostProc.RunUsersAssembly()
   at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean ignoreSyncCtx)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Threading.ThreadHelper.ThreadStart()

Đây là một cách giải quyết tôi thấy rằng nó hoạt động cho tất cả các trường hợp (bao gồm cả người điều phối bị đình chỉ). Đó không phải là mã của tôi và tôi vẫn đang làm việc để hiểu đầy đủ về nó, nhưng nó vẫn hoạt động.

Nó có thể được gọi bằng cách sử dụng:

customerList = AsyncHelpers.RunSync<List<Customer>>(() => GetCustomers());

Mã là từ đây

public static class AsyncHelpers
{
    /// <summary>
    /// Execute's an async Task<T> method which has a void return value synchronously
    /// </summary>
    /// <param name="task">Task<T> method to execute</param>
    public static void RunSync(Func<Task> task)
    {
        var oldContext = SynchronizationContext.Current;
        var synch = new ExclusiveSynchronizationContext();
        SynchronizationContext.SetSynchronizationContext(synch);
        synch.Post(async _ =>
        {
            try
            {
                await task();
            }
            catch (Exception e)
            {
                synch.InnerException = e;
                throw;
            }
            finally
            {
                synch.EndMessageLoop();
            }
        }, null);
        synch.BeginMessageLoop();

        SynchronizationContext.SetSynchronizationContext(oldContext);
    }

    /// <summary>
    /// Execute's an async Task<T> method which has a T return type synchronously
    /// </summary>
    /// <typeparam name="T">Return Type</typeparam>
    /// <param name="task">Task<T> method to execute</param>
    /// <returns></returns>
    public static T RunSync<T>(Func<Task<T>> task)
    {
        var oldContext = SynchronizationContext.Current;
        var synch = new ExclusiveSynchronizationContext();
        SynchronizationContext.SetSynchronizationContext(synch);
        T ret = default(T);
        synch.Post(async _ =>
        {
            try
            {
                ret = await task();
            }
            catch (Exception e)
            {
                synch.InnerException = e;
                throw;
            }
            finally
            {
                synch.EndMessageLoop();
            }
        }, null);
        synch.BeginMessageLoop();
        SynchronizationContext.SetSynchronizationContext(oldContext);
        return ret;
    }

    private class ExclusiveSynchronizationContext : SynchronizationContext
    {
        private bool done;
        public Exception InnerException { get; set; }
        readonly AutoResetEvent workItemsWaiting = new AutoResetEvent(false);
        readonly Queue<Tuple<SendOrPostCallback, object>> items =
            new Queue<Tuple<SendOrPostCallback, object>>();

        public override void Send(SendOrPostCallback d, object state)
        {
            throw new NotSupportedException("We cannot send to our same thread");
        }

        public override void Post(SendOrPostCallback d, object state)
        {
            lock (items)
            {
                items.Enqueue(Tuple.Create(d, state));
            }
            workItemsWaiting.Set();
        }

        public void EndMessageLoop()
        {
            Post(_ => done = true, null);
        }

        public void BeginMessageLoop()
        {
            while (!done)
            {
                Tuple<SendOrPostCallback, object> task = null;
                lock (items)
                {
                    if (items.Count > 0)
                    {
                        task = items.Dequeue();
                    }
                }
                if (task != null)
                {
                    task.Item1(task.Item2);
                    if (InnerException != null) // the method threw an exeption
                    {
                        throw new AggregateException("AsyncHelpers.Run method threw an exception.", InnerException);
                    }
                }
                else
                {
                    workItemsWaiting.WaitOne();
                }
            }
        }

        public override SynchronizationContext CreateCopy()
        {
            return this;
        }
    }
}

Được thông báo câu trả lời này là ba tuổi. Tôi đã viết nó chủ yếu dựa trên trải nghiệm với .Net 4.0 và rất ít với 4.5 đặc biệt là vớiasync-await . Nói chung đó là một giải pháp đơn giản tốt đẹp, nhưng đôi khi nó phá vỡ mọi thứ. Xin vui lòng đọc các cuộc thảo luận trong các ý kiến.

.Net 4.5

Chỉ cần sử dụng này:

// For Task<T>: will block until the task is completed...
var result = task.Result; 

// For Task (not Task<T>): will block until the task is completed...
task2.RunSynchronously();

Xem: TaskAwaiter , Task.Result , Task.RunSyn đồng bộ

.Net 4.0

Dùng cái này:

var x = (IAsyncResult)task;
task.Start();

x.AsyncWaitHandle.WaitOne();

... Hoặc cái này:

task.Start();
task.Wait();

Ngạc nhiên không ai đề cập đến điều này:

public Task<int> BlahAsync()
{
    // ...
}

int result = BlahAsync().GetAwaiter().GetResult();

Không đẹp như một số phương pháp khác ở đây, nhưng nó có những lợi ích sau:

• nó không nuốt ngoại lệ (như Wait)
• nó sẽ không bao gồm bất kỳ trường hợp ngoại lệ nào được ném vào AggregateException(như Result)
• làm việc cho cả hai Taskvà Task<T>( hãy tự mình thử! )

Ngoài ra, vì GetAwaiterđược gõ vịt, nên nó hoạt động cho bất kỳ đối tượng nào được trả về từ một phương thức không đồng bộ (như ConfiguredAwaitablehoặc YieldAwaitable), không chỉ Nhiệm vụ.

chỉnh sửa: Xin lưu ý rằng phương pháp này (hoặc sử dụng .Result) có thể bị bế tắc, trừ khi bạn đảm bảo thêm .ConfigureAwait(false)mỗi khi bạn chờ đợi, cho tất cả các phương thức không đồng bộ có thể đạt được BlahAsync()(không chỉ các phương thức mà nó gọi trực tiếp). Giải thích .

// In BlahAsync() body
await FooAsync(); // BAD!
await FooAsync().ConfigureAwait(false); // Good... but make sure FooAsync() and
                                        // all its descendants use ConfigureAwait(false)
                                        // too. Then you can be sure that
                                        // BlahAsync().GetAwaiter().GetResult()
                                        // won't deadlock.

Nếu bạn quá lười để thêm .ConfigureAwait(false)ở mọi nơi và bạn không quan tâm đến hiệu suất, bạn có thể thay thế

Task.Run(() => BlahAsync()).GetAwaiter().GetResult()

Việc chạy tác vụ trên nhóm luồng đơn giản hơn nhiều so với việc cố gắng lừa bộ lập lịch để chạy nó một cách đồng bộ. Bằng cách đó bạn có thể chắc chắn rằng nó sẽ không bế tắc. Hiệu suất bị ảnh hưởng vì chuyển đổi ngữ cảnh.

Task<MyResult> DoSomethingAsync() { ... }

// Starts the asynchronous task on a thread-pool thread.
// Returns a proxy to the original task.
Task<MyResult> task = Task.Run(() => DoSomethingAsync());

// Will block until the task is completed...
MyResult result = task.Result; 

Tôi đang tìm hiểu về async / await, và gặp phải tình huống tôi cần gọi một phương thức async một cách đồng bộ. Làm thế nào tôi có thể làm điều đó?

Câu trả lời tốt nhất là bạn không , với các chi tiết phụ thuộc vào "tình huống" là gì.

Nó có phải là một getter / setter không? Trong hầu hết các trường hợp, tốt hơn là có các phương thức không đồng bộ hơn là "thuộc tính không đồng bộ". (Để biết thêm thông tin, hãy xem bài đăng trên blog của tôi về các thuộc tính không đồng bộ ).

Đây có phải là ứng dụng MVVM và bạn muốn liên kết dữ liệu không đồng bộ? Sau đó sử dụng một cái gì đó giống như của tôi NotifyTask, như được mô tả trong bài viết MSDN của tôi về ràng buộc dữ liệu không đồng bộ .

Nó có phải là một nhà xây dựng? Sau đó, bạn có thể muốn xem xét một phương pháp nhà máy không đồng bộ. (Để biết thêm thông tin, hãy xem bài đăng trên blog của tôi về các nhà xây dựng không đồng bộ ).

Hầu như luôn luôn có một câu trả lời tốt hơn là thực hiện đồng bộ hóa quá mức.

Nếu tình huống của bạn không thể xảy ra (và bạn biết điều này bằng cách đặt câu hỏi ở đây mô tả tình huống ), thì tôi khuyên bạn chỉ nên sử dụng mã đồng bộ. Async tất cả các cách là tốt nhất; đồng bộ tất cả các cách là tốt nhất thứ hai. Đồng bộ hóa không đồng bộ không được khuyến nghị.

Tuy nhiên, có một số tình huống cần đồng bộ hóa quá mức không đồng bộ. Cụ thể, bạn bị ràng buộc bởi mã gọi để bạn phải đồng bộ hóa (và hoàn toàn không có cách nào để suy nghĩ lại hoặc cấu trúc lại mã của bạn để cho phép không đồng bộ) và bạn phải gọi mã async. Đây là một tình huống rất hiếm, nhưng đôi khi nó xuất hiện.

Trong trường hợp đó, bạn sẽ cần sử dụng một trong những hack được mô tả trong bài viết của tôi về phát triển trường nâuasync , cụ thể:

• Chặn (ví dụ GetAwaiter().GetResult():). Lưu ý rằng điều này có thể gây ra bế tắc (như tôi mô tả trên blog của tôi).
• Chạy mã trên một chuỗi chủ đề nhóm (ví dụ, Task.Run(..).GetAwaiter().GetResult()). Lưu ý rằng điều này sẽ chỉ hoạt động nếu mã không đồng bộ có thể chạy trên luồng nhóm luồng (nghĩa là không phụ thuộc vào bối cảnh UI hoặc ASP.NET).
• Các vòng lặp tin nhắn lồng nhau. Lưu ý rằng điều này sẽ chỉ hoạt động nếu mã không đồng bộ chỉ giả sử một bối cảnh đơn luồng, không phải là một loại ngữ cảnh cụ thể (rất nhiều mã UI và ASP.NET mong đợi một bối cảnh cụ thể).

Các vòng lặp tin nhắn lồng nhau là nguy hiểm nhất trong tất cả các hack, bởi vì nó gây ra lối vào lại . Lý do nhập lại cực kỳ khó khăn để lý do và (IMO) là nguyên nhân của hầu hết các lỗi ứng dụng trên Windows. Cụ thể, nếu bạn đang sử dụng luồng UI và bạn chặn hàng đợi công việc (chờ công việc async hoàn thành), thì CLR thực sự thực hiện một số thông báo cho bạn - nó thực sự sẽ xử lý một số tin nhắn Win32 từ bên trong bạn mã . Ồ, và bạn không biết tin nhắn nào - khi Chris Brumme nói "Sẽ không tuyệt vời khi biết chính xác những gì sẽ được bơm? Thật không may, bơm là một nghệ thuật đen vượt quá tầm hiểu biết." , sau đó chúng tôi thực sự không có hy vọng để biết.

Vì vậy, khi bạn chặn như thế này trên một luồng UI, bạn sẽ gặp rắc rối. Một trích dẫn khác từ cùng một bài báo: "Thỉnh thoảng, khách hàng trong hoặc ngoài công ty phát hiện ra rằng chúng tôi đang bơm tin nhắn trong khi chặn được quản lý trên STA [luồng UI]. Đây là một mối quan tâm chính đáng, bởi vì họ biết rằng nó rất khó để viết mã mạnh mẽ khi đối mặt với sự hồi sinh. "

Vâng, đúng vậy. Rất khó để viết mã đó là mạnh mẽ khi đối mặt với reentrancy. Và các vòng lặp thông điệp lồng nhau buộc bạn phải viết mã mạnh mẽ khi đối mặt với reentrancy. Đây là lý do tại sao câu trả lời được chấp nhận (và được đánh giá cao nhất) cho câu hỏi này là cực kỳ nguy hiểm trong thực tế.

Nếu bạn hoàn toàn không có tất cả các tùy chọn khác - bạn không thể thiết kế lại mã của mình, bạn không thể cấu trúc lại nó thành không đồng bộ - bạn bị ép buộc bởi mã gọi không thể thay đổi được đồng bộ hóa - bạn không thể thay đổi mã xuôi dòng để được đồng bộ hóa - bạn không thể chặn - bạn không thể chạy mã async trên một luồng riêng biệt - sau đó và chỉ sau đó bạn mới nên xem xét việc chấp nhận reentrancy.

Nếu bạn thấy mình ở góc này, tôi khuyên bạn nên sử dụng một cái gì đó như Dispatcher.PushFramecho các ứng dụng WPF , lặp lại với Application.DoEventscác ứng dụng WinForm và cho trường hợp chung, của riêng tôi AsyncContext.Run.

Nếu tôi đang đọc đúng câu hỏi của bạn - mã muốn cuộc gọi đồng bộ đến một phương thức không đồng bộ đang thực thi trên một chuỗi điều phối bị treo. Và bạn muốn thực sự đồng bộ chặn luồng đó cho đến khi phương thức async được hoàn thành.

Các phương thức Async trong C # 5 được hỗ trợ bằng cách cắt hiệu quả phương thức thành các phần dưới mui xe và trả về một phương Taskthức có thể theo dõi sự hoàn thành tổng thể của toàn bộ shabang. Tuy nhiên, làm thế nào các phương thức băm nhỏ thực thi có thể phụ thuộc vào loại biểu thức được truyền cho awaittoán tử.

Hầu hết thời gian, bạn sẽ sử dụng awaitbiểu thức loại Task. Việc triển khai awaitmô hình của nhiệm vụ là "thông minh" ở chỗ nó làm theo SynchronizationContext, điều này về cơ bản gây ra những điều sau đây:

1. Nếu luồng nhập vào awaitnằm trên luồng vòng lặp thông báo của Dispatcher hoặc WinForms, thì nó đảm bảo rằng các khối của phương thức async xảy ra như là một phần của quá trình xử lý hàng đợi tin nhắn.
2. Nếu luồng nhập vào awaitlà trên luồng của luồng xử lý, thì các đoạn còn lại của phương thức async xảy ra ở bất kỳ đâu trên nhóm luồng.

Đó là lý do tại sao bạn có thể gặp vấn đề - việc triển khai phương thức async đang cố gắng chạy phần còn lại trên Bộ điều phối - mặc dù nó bị treo.

.... sao lưu! ....

Tôi phải đặt câu hỏi, tại sao bạn lại cố gắng chặn đồng bộ trên một phương thức không đồng bộ? Làm như vậy sẽ đánh bại mục đích tại sao phương thức muốn được gọi là không đồng bộ. Nói chung, khi bạn bắt đầu sử dụng awaittrên phương thức Bộ điều phối hoặc Giao diện người dùng, bạn sẽ muốn biến toàn bộ luồng UI của mình không đồng bộ. Ví dụ: nếu callstack của bạn giống như sau:

1. [Hàng đầu] WebRequest.GetResponse()
2. YourCode.HelperMethod()
3. YourCode.AnotherMethod()
4. YourCode.EventHandlerMethod()
5. [UI Code].Plumbing()- WPFhoặc WinFormsMã
6. [Vòng lặp tin nhắn] - WPFhoặc WinFormsVòng lặp tin nhắn

Sau đó, khi mã đã được chuyển đổi để sử dụng async, thông thường bạn sẽ kết thúc bằng

1. [Hàng đầu] WebRequest.GetResponseAsync()
2. YourCode.HelperMethodAsync()
3. YourCode.AnotherMethodAsync()
4. YourCode.EventHandlerMethodAsync()
5. [UI Code].Plumbing()- WPFhoặc WinFormsMã
6. [Vòng lặp tin nhắn] - WPFhoặc WinFormsVòng lặp tin nhắn

Trả lời thực tế

Lớp AsyncHelpers ở trên thực sự hoạt động vì nó hoạt động giống như một vòng lặp thông báo lồng nhau, nhưng nó cài đặt cơ chế song song của riêng nó cho Bộ điều phối thay vì cố gắng thực thi trên chính Bộ điều phối. Đó là một cách giải quyết cho vấn đề của bạn.

Một cách giải quyết khác là thực thi phương thức async của bạn trên một luồng luồng, và sau đó đợi cho nó hoàn thành. Làm như vậy rất dễ dàng - bạn có thể làm điều đó với đoạn mã sau:

var customerList = TaskEx.RunEx(GetCustomers).Result;

API cuối cùng sẽ là Task.Run (...), nhưng với CTP, bạn sẽ cần các hậu tố Ex ( giải thích ở đây ).

Điều này đang làm việc tốt cho tôi

public static class TaskHelper
{
    public static void RunTaskSynchronously(this Task t)
    {
        var task = Task.Run(async () => await t);
        task.Wait();
    }

    public static T RunTaskSynchronously<T>(this Task<T> t)
    {
        T res = default(T);
        var task = Task.Run(async () => res = await t);
        task.Wait();
        return res;
    }
}

Cách đơn giản nhất mà tôi đã tìm thấy để chạy tác vụ một cách đồng bộ và không chặn luồng UI là sử dụng RunSynyncly () như:

Task t = new Task(() => 
{ 
   //.... YOUR CODE ....
});
t.RunSynchronously();

Trong trường hợp của tôi, tôi có một sự kiện phát sinh khi có điều gì đó xảy ra. Tôi không biết nó sẽ xảy ra bao nhiêu lần. Vì vậy, tôi sử dụng mã ở trên trong sự kiện của mình, vì vậy bất cứ khi nào nó kích hoạt, nó sẽ tạo ra một nhiệm vụ. Nhiệm vụ được thực hiện đồng bộ và nó hoạt động rất tốt cho tôi. Tôi chỉ ngạc nhiên khi tôi mất quá nhiều thời gian để tìm hiểu điều này vì nó đơn giản như thế nào. Thông thường, các khuyến nghị phức tạp hơn nhiều và dễ bị lỗi. Đây là nó đơn giản và sạch sẽ.

Tôi đã phải đối mặt với nó một vài lần, chủ yếu là trong thử nghiệm đơn vị hoặc trong phát triển dịch vụ windows. Hiện tại tôi luôn sử dụng tính năng này:

        var runSync = Task.Factory.StartNew(new Func<Task>(async () =>
        {
            Trace.WriteLine("Task runSync Start");
            await TaskEx.Delay(2000); // Simulates a method that returns a task and
                                      // inside it is possible that there
                                      // async keywords or anothers tasks
            Trace.WriteLine("Task runSync Completed");
        })).Unwrap();
        Trace.WriteLine("Before runSync Wait");
        runSync.Wait();
        Trace.WriteLine("After runSync Waited");

Nó đơn giản, dễ dàng và tôi không có vấn đề gì.

Tôi đã tìm thấy mã này tại thành phần Microsoft.AspNet.Identity.Core và nó hoạt động.

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

// Microsoft.AspNet.Identity.AsyncHelper
public static TResult RunSync<TResult>(Func<Task<TResult>> func)
{
    CultureInfo cultureUi = CultureInfo.CurrentUICulture;
    CultureInfo culture = CultureInfo.CurrentCulture;
    return AsyncHelper._myTaskFactory.StartNew<Task<TResult>>(delegate
    {
        Thread.CurrentThread.CurrentCulture = culture;
        Thread.CurrentThread.CurrentUICulture = cultureUi;
        return func();
    }).Unwrap<TResult>().GetAwaiter().GetResult();
}

Chỉ cần một lưu ý nhỏ - cách tiếp cận này:

Task<Customer> task = GetCustomers();
task.Wait()

hoạt động cho WinRT.

Hãy để tôi giải thích:

private void TestMethod()
{
    Task<Customer> task = GetCustomers(); // call async method as sync and get task as result
    task.Wait(); // wait executing the method
    var customer = task.Result; // get's result.
    Debug.WriteLine(customer.Name); //print customer name
}
public class Customer
{
    public Customer()
    {
        new ManualResetEvent(false).WaitOne(TimeSpan.FromSeconds(5));//wait 5 second (long term operation)
    }
    public string Name { get; set; }
}
private Task<Customer> GetCustomers()
{
    return Task.Run(() => new Customer
    {
        Name = "MyName"
    });
}

Hơn nữa, phương pháp này chỉ hoạt động cho các giải pháp Windows Store!

Lưu ý: Cách này không an toàn cho chủ đề nếu bạn gọi phương thức của mình bên trong phương thức async khác (theo nhận xét của @Servy)

Trong mã của bạn, lần đầu tiên bạn chờ tác vụ thực thi nhưng bạn chưa khởi động nó nên nó chờ vô thời hạn. Thử cái này:

Task<Customer> task = GetCustomers();
task.RunSynchronously();

Biên tập:

Bạn nói rằng bạn nhận được một ngoại lệ. Xin vui lòng gửi thêm chi tiết, bao gồm cả theo dõi ngăn xếp.
Mono chứa trường hợp kiểm tra sau:

[Test]
public void ExecuteSynchronouslyTest ()
{
        var val = 0;
        Task t = new Task (() => { Thread.Sleep (100); val = 1; });
        t.RunSynchronously ();

        Assert.AreEqual (1, val);
}

Kiểm tra nếu điều này làm việc cho bạn. Nếu không, mặc dù rất khó xảy ra, bạn có thể có một số bản dựng Async CTP kỳ quặc. Nếu nó hoạt động, bạn có thể muốn kiểm tra chính xác trình biên dịch tạo ra gì và cách Taskkhởi tạo khác với mẫu này.

Chỉnh sửa # 2:

Tôi đã kiểm tra với Reflector rằng ngoại lệ bạn mô tả xảy ra khi m_actioncó null. Điều này hơi lạ, nhưng tôi không phải là chuyên gia về Async CTP. Như tôi đã nói, bạn nên dịch ngược mã của bạn và xem như thế nào chính xác Taskđang được instantiated bất kỳ cách đi của nó m_actionlà null.

PS Điều gì đối phó với các downvote thường xuyên? Quan tâm đến công phu?

Đã thử nghiệm trong .Net 4.6. Nó cũng có thể tránh bế tắc.

Đối với phương thức async trở lại Task.

Task DoSomeWork();
Task.Run(async () => await DoSomeWork()).Wait();

Đối với phương thức async trở lại Task<T>

Task<T> GetSomeValue();
var result = Task.Run(() => GetSomeValue()).Result;

Chỉnh sửa :

Nếu người gọi đang chạy trong luồng nhóm luồng (hoặc người gọi cũng đang trong một tác vụ), nó vẫn có thể gây ra bế tắc trong một số trường hợp.

sử dụng đoạn mã dưới đây

Task.WaitAll(Task.Run(async () => await service.myAsyncMethod()));

Tại sao không tạo một cuộc gọi như:

Service.GetCustomers();

đó không phải là không đồng bộ.

Câu trả lời này được thiết kế cho bất kỳ ai đang sử dụng WPF cho .NET 4.5.

Nếu bạn cố thực hiện Task.Run()trên luồng GUI, thì task.Wait()sẽ bị treo vô thời hạn, nếu bạn không có asynctừ khóa trong định nghĩa hàm.

Phương thức mở rộng này giải quyết vấn đề bằng cách kiểm tra xem liệu chúng ta có đang ở trên luồng GUI hay không và nếu có, hãy chạy tác vụ trên luồng xử lý WPF.

Lớp này có thể đóng vai trò là chất kết dính giữa thế giới async / await và thế giới không async / await, trong các tình huống không thể tránh khỏi, chẳng hạn như các thuộc tính MVVM hoặc phụ thuộc vào các API khác không sử dụng async / await.

/// <summary>
///     Intent: runs an async/await task synchronously. Designed for use with WPF.
///     Normally, under WPF, if task.Wait() is executed on the GUI thread without async
///     in the function signature, it will hang with a threading deadlock, this class 
///     solves that problem.
/// </summary>
public static class TaskHelper
{
    public static void MyRunTaskSynchronously(this Task task)
    {
        if (MyIfWpfDispatcherThread)
        {
            var result = Dispatcher.CurrentDispatcher.InvokeAsync(async () => { await task; });
            result.Wait();
            if (result.Status != DispatcherOperationStatus.Completed)
            {
                throw new Exception("Error E99213. Task did not run to completion.");
            }
        }
        else
        {
            task.Wait();
            if (task.Status != TaskStatus.RanToCompletion)
            {
                throw new Exception("Error E33213. Task did not run to completion.");
            }
        }
    }

    public static T MyRunTaskSynchronously<T>(this Task<T> task)
    {       
        if (MyIfWpfDispatcherThread)
        {
            T res = default(T);
            var result = Dispatcher.CurrentDispatcher.InvokeAsync(async () => { res = await task; });
            result.Wait();
            if (result.Status != DispatcherOperationStatus.Completed)
            {
                throw new Exception("Error E89213. Task did not run to completion.");
            }
            return res;
        }
        else
        {
            T res = default(T);
            var result = Task.Run(async () => res = await task);
            result.Wait();
            if (result.Status != TaskStatus.RanToCompletion)
            {
                throw new Exception("Error E12823. Task did not run to completion.");
            }
            return res;
        }
    }

    /// <summary>
    ///     If the task is running on the WPF dispatcher thread.
    /// </summary>
    public static bool MyIfWpfDispatcherThread
    {
        get
        {
            return Application.Current.Dispatcher.CheckAccess();
        }
    }
}

Đơn giản chỉ cần gọi .Result;hoặc .Wait()là một nguy cơ cho bế tắc như nhiều người đã nói trong các ý kiến. Vì hầu hết chúng ta thích oneliners, bạn có thể sử dụng chúng cho.Net 4.5<

Có được giá trị thông qua phương thức async:

var result = Task.Run(() => asyncGetValue()).Result;

Gọi đồng bộ một phương thức async

Task.Run(() => asyncMethod()).Wait();

Không có vấn đề bế tắc sẽ xảy ra do việc sử dụng Task.Run.

Nguồn:

https://stackoverflow.com/a/32429753/3850405

Tôi nghĩ rằng phương pháp trợ giúp sau đây cũng có thể giải quyết vấn đề.

private TResult InvokeAsyncFuncSynchronously<TResult>(Func< Task<TResult>> func)
    {
        TResult result = default(TResult);
        var autoResetEvent = new AutoResetEvent(false);

        Task.Run(async () =>
        {
            try
            {
                result = await func();
            }
            catch (Exception exc)
            {
                mErrorLogger.LogError(exc.ToString());
            }
            finally
            {
                autoResetEvent.Set();
            }
        });
        autoResetEvent.WaitOne();

        return result;
    }

Có thể được sử dụng theo cách sau:

InvokeAsyncFuncSynchronously(Service.GetCustomersAsync);

Đây là công việc cho tôi

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

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

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

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

    class SomeClass
    {
        public async Task<object> LoginAsync(object loginInfo)
        {
            return await Task.FromResult(0);
        }
        public object Login(object loginInfo)
        {
            return AsyncHelper.RunSync(() => LoginAsync(loginInfo));
            //return this.LoginAsync(loginInfo).Result.Content;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            var someClass = new SomeClass();

            Console.WriteLine(someClass.Login(1));
            Console.ReadLine();
        }
    }
}

Tôi đã thấy rằng SpinWait hoạt động khá tốt cho việc này.

var task = Task.Run(()=>DoSomethingAsyncronous());

if(!SpinWait.SpinUntil(()=>task.IsComplete, TimeSpan.FromSeconds(30)))
{//Task didn't complete within 30 seconds, fail...
   return false;
}

return true;

Cách tiếp cận trên không cần sử dụng .Result hoặc .Wait (). Nó cũng cho phép bạn chỉ định thời gian chờ để bạn không bị kẹt mãi mãi trong trường hợp nhiệm vụ không bao giờ hoàn thành.

Trên wp8:

Gói nó:

Task GetCustomersSynchronously()
{
    Task t = new Task(async () =>
    {
        myCustomers = await GetCustomers();
    }
    t.RunSynchronously();
}

Gọi nó đi:

GetCustomersSynchronously();

    private int GetSync()
    {
        try
        {
            ManualResetEvent mre = new ManualResetEvent(false);
            int result = null;

            Parallel.Invoke(async () =>
            {
                result = await SomeCalcAsync(5+5);
                mre.Set();
            });

            mre.WaitOne();
            return result;
        }
        catch (Exception)
        {
            return null;
        }
    }

Hoặc bạn có thể đi với:

customerList = Task.Run<List<Customer>>(() => { return GetCustomers(); }).Result;

Để biên dịch, hãy chắc chắn rằng bạn tham khảo phần mở rộng:

System.Net.Http.Formatting

Hãy thử mã sau đây nó hoạt động với tôi:

public async void TaskSearchOnTaskList (SearchModel searchModel)
{
    try
    {
        List<EventsTasksModel> taskSearchList = await Task.Run(
            () => MakeasyncSearchRequest(searchModel),
            cancelTaskSearchToken.Token);

        if (cancelTaskSearchToken.IsCancellationRequested
                || string.IsNullOrEmpty(rid_agendaview_search_eventsbox.Text))
        {
            return;
        }

        if (taskSearchList == null || taskSearchList[0].result == Constants.ZERO)
        {
            RunOnUiThread(() => {
                textViewNoMembers.Visibility = ViewStates.Visible;                  
                taskListView.Visibility = ViewStates.Gone;
            });

            taskSearchRecureList = null;

            return;
        }
        else
        {
            taskSearchRecureList = TaskFooterServiceLayer
                                       .GetRecurringEvent(taskSearchList);

            this.SetOnAdapter(taskSearchRecureList);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine("ActivityTaskFooter -> TaskSearchOnTaskList:" + ex.Message);
    }
}