C#如何确保一个异步方法在另一个异步方法之后执行

Question

我看过一些关于async 和await 的帖子以及它们的实际工作原理，但我还是有点困惑。假设我有两个 async 方法，我想确保第二个在第一个完成后开始。例如考虑这样的事情：

    public async Task MyMethod(Item x)
    {
        await AddRequest(x); // 1. Add an item asynchronously 

        // make sure 2 starts after 1 completes

        await GetAllRequest(); // 2. get all items asynchronously 
    }

那么，确保发生这种情况的正确方法是什么？

更新：

为了尝试提供一个最小、完整和可验证的示例：

我在 WPF 应用程序中有 2 个 WCF 服务来与 Oracle WebCenter Content(UCM) 通信。这是我背后代码的最小版本：

UCM 服务添加新客户：

    public static async Task<ServiceResult> CheckInCustomer(Customer c)
    {
        CheckInSoapClient client = new CheckInSoapClient();
        using (OperationContextScope scope = new OperationContextScope(client.InnerChannel))
        {
                // an async method in Oracle WebContent services to insert new content
                result = await client.CheckInUniversalAsync(c);
        }
        return new ServiceResult();
    }

UCM 服务获取所有客户：

    public static async Task<Tuple<ServiceResult, QuickSearchResponse>> GetAllCustomers()
    {
        ServiceResult error;
        var result = new QuickSearchResponse();
        SearchSoapClient client = new SearchSoapClient();
        using (OperationContextScope scope = new OperationContextScope(client.InnerChannel))
        {
                // an async method in Oracle WebContent services to search for contents
                result = await client.QuickSearchAsync(queryString);
        }
            return new Tuple<ServiceResult, QuickSearchResponse>(error, result);
    }

在 UI 中添加绑定到按钮命令的客户异步方法：

    private async Task AddCustomer()
    {
        var result = await CheckInCustomer(NewCustomer);
        if (!result.HasError)
            await GetAllCustomers();
    }

    public ICommand AddCustomerCommand
    {
        get
        {
            _addCustomerCommand = new RelayCommand(async param => await AddCustomer(), null);
        }
    }

获取所有客户异步方法（Items 绑定到 UI 中的 DataGrid）：

    private async Task GetAllCustomers()
    {
        Items.Clear();
        var searchResult = await GetCustomersInfoAsync();
        if (!searchResult.HasError)
        {
            foreach (var item in searchResult)
                Items.Add(new CustomerVm(item));
        }
    }

现在，当我添加一个新的Customer 时，我希望在我首先插入客户然后获取所有客户时在DataGrid 中看到新创建的项目。但是这段代码的行为是随机的，这意味着有时列表会在插入几秒钟后显示新创建的客户，有时则不会。

Answer 1

您提供的代码实际上可以满足您的需求。

public async Task MyMethod(Item x)
{
    await AddRequestAsync(x); 

    await GetAllRequestAsync(); 
}

但是，如果您谈论的是它们之间不可预测的“非常非常短”的延迟，并且您想确保没有延迟，那是不可能的。

Answer 2

Await - （首选，必须在 ContinueWith 上使用）（TY 到 @Taffer 和 @Michael cmets）等待新创建的任务完成，并确保在等待任务执行完成后继续执行。

您的第一个 func AddRequest 将在移至 GetAllRequest 之前提供结果。

public async Task MyMethod(Item x)
{
    await AddRequest(x);
    await GetAllRequest();
}

这里我不明白的是异步是指第一个 方法可以保留未完成并执行主要任务 继续。所以第二种方法的某些部分可能会运行 在第一种方法完成之前。

之所以称为异步编程，是因为运行时会在遇到 await 关键字（类似于迭代器中的 yield）时捕获程序的状态，并在等待的任务完成后恢复状态，以便继续在正确的上下文中运行。..

但是如果你只想在第一个任务之后运行它，这是你可以做的。

使用 ContinueWith - 它的方法可用于任务，允许在任务完成执行后执行代码。简而言之，它允许继续。

public async Task MyMethod(Item x)
{
    var req = AddRequest(x).ContinueWith(async (t1) =>
               {
                  await GetAllRequest();
               }); 
}