受到其他一些答案的启发，我创建了以下简单的帮助方法:

public static TResult RunSync<TResult>(Func<Task<TResult>> method)
{
    var task = method();
    return task.GetAwaiter().GetResult();
}

public static void RunSync(Func<Task> method)
{
    var task = method();
    task.GetAwaiter().GetResult();
}

调用方法如下(取决于你是否返回值):

RunSync(() => Foo());
var result = RunSync(() => FooWithResult());

注意，原始问题public async void Foo()中的签名是不正确的。它应该是公共async Task Foo()，因为对于不返回值的异步方法，应该返回Task而不是void(是的，有一些罕见的例外)。

您可以从同步代码中调用任何异步方法，直到您需要等待它们，在这种情况下，它们也必须被标记为异步。

正如很多人在这里建议的那样，您可以在同步方法中对结果任务调用Wait()或Result，但最终会在该方法中进行阻塞调用，这在某种程度上违背了异步的目的。

如果你真的不能让你的方法异步，你不想锁定同步方法，那么你将不得不使用一个回调方法，把它作为参数传递给任务上的ContinueWith()方法。

这是最简单的解决办法。我在网上的某个地方看到它，我不记得在哪里了，但我一直在成功地使用它。它不会死锁调用线程。

    void SynchronousFunction()
    {
        Task.Run(Foo).Wait();
    }

    string SynchronousFunctionReturnsString()
    {
        return Task.Run(Foo).Result;
    }

    string SynchronousFunctionReturnsStringWithParam(int id)
    {
        return Task.Run(() => Foo(id)).Result;
    }

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方法。最大的区别是逻辑流没有中断，这使得读写更容易。

添加一个解决方案，最终解决了我的问题，希望能节省别人的时间。

首先阅读Stephen Cleary的几篇文章:

异步和等待 不要阻塞异步代码

在“不要阻塞异步代码”中的“两个最佳实践”中，第一个对我来说不适用，第二个不适用(基本上如果我可以使用await，我就会使用!)。

下面是我的解决方案:将调用包装在一个Task中。运行<>(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;
    }
}

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

希望这能有所帮助!