这个答案是为任何在。net 4.5中使用WPF的人设计的。

如果你试图在GUI线程上执行Task.Run()，那么task.Wait()将无限期挂起，如果你的函数定义中没有async关键字的话。

这个扩展方法通过检查我们是否在GUI线程上解决了这个问题，如果是，就在WPF调度程序线程上运行任务。

在不可避免的情况下，例如MVVM属性或对其他不使用async/await的api的依赖，该类可以充当异步/await世界和非异步/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();
        }
    }
}

在线程池上运行任务要简单得多，而不是试图欺骗调度器以同步方式运行它。这样可以确保它不会死锁。由于上下文切换会影响性能。

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; 

如果我没看错你的问题——想要同步调用异步方法的代码正在挂起的调度程序线程上执行。你想要同步地阻塞那个线程直到async方法完成。

c# 5中的异步方法是通过有效地将方法切碎，并返回一个可以跟踪整个shabang的整体完成的Task来实现的。然而，被分割的方法如何执行取决于传递给await操作符的表达式类型。

大多数情况下，您将在Task类型的表达式上使用await。Task对await模式的实现是“智能的”，因为它遵循SynchronizationContext，这基本上会导致以下情况发生:

如果进入await的线程位于Dispatcher或WinForms消息循环线程上，它将确保async方法的块作为消息队列处理的一部分发生。 如果进入await的线程位于线程池线程上，则异步方法的剩余块发生在线程池的任何位置。

这就是为什么您可能会遇到问题——异步方法实现试图在Dispatcher上运行其余部分——即使它被挂起。

．．．． 备份!．...

我要问一个问题，为什么你要在异步方法上同步阻塞?这样做会违背为什么要异步调用该方法的目的。通常，当您开始在Dispatcher或UI方法上使用await时，您将希望将整个UI流转为异步。例如，如果你的调用堆栈如下所示:

(高级)WebRequest.GetResponse () YourCode.HelperMethod () YourCode.AnotherMethod () YourCode.EventHandlerMethod () [UI Code].Plumbing() - WPF或WinForms代码 [消息循环]- WPF或WinForms消息循环

然后，一旦代码转换为使用异步，您通常会得到

(高级)WebRequest.GetResponseAsync () YourCode.HelperMethodAsync () YourCode.AnotherMethodAsync () YourCode.EventHandlerMethodAsync () [UI Code].Plumbing() - WPF或WinForms代码 [消息循环]- WPF或WinForms消息循环

实际回答

上面的AsyncHelpers类实际上可以工作，因为它的行为就像一个嵌套的消息循环，但它将自己的并行机制安装到Dispatcher上，而不是试图在Dispatcher本身上执行。这是解决你的问题的一个办法。

另一种解决方法是在线程池线程上执行async方法，然后等待它完成。这样做很容易-你可以用下面的代码片段来做:

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

最终的API将是Task.Run(…)，但对于CTP，您将需要Ex后缀(此处解释)。

请注意，这个答案是三年前的。我主要是根据。net 4.0的使用经验编写的，很少使用4.5，尤其是async-await。 一般来说，这是一个很好的简单的解决方案，但有时它会破坏一些东西。请阅读评论中的讨论。

net 4.5

就用这个吧:

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

看到的: TaskAwaiter, 的任务。结果, 的任务。RunSynchronously

net 4.0

用这个:

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

x.AsyncWaitHandle.WaitOne();

.．.或:

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

尝试以下代码，它为我工作:

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

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