Eric Lippert 的异步编程示例

Question

我正在尝试使用 Eric Lippert 在 2011 年的 Asynchronous Programming - Easier Asynchronous Programming with the New Visual Studio Async CTP 中的示例了解 C# 中异步编程的基础知识。

我已经为上一个代码示例中引用的方法填写了存根，我希望在命令行上看到的是：

Start obtain order
Finish obtain order
Start obtain ingredients
Start obtain recipe
Finish obtain ingredients
Finish obtain recipe
Start recipe prepare meal
Finish recipe prepare meal
Diner receives meal

但相反，我看到每个方法都被依次调用 - 似乎没有什么是异步的。

我的代码有错误，还是我误解了它的工作原理？

非常感谢您的指导。

namespace AsyncAwait
    {
    using System;
    using System.Threading.Tasks;

    internal class Program
    {
        internal class Order
        {
        }

        internal class Ingredients
        {
        }

        internal class Recipe
        {
            internal async Task<Meal> PrepareAsync(Ingredients ingredients)
            {
                Console.WriteLine("Start recipe prepare meal");
                await Task.Delay(4 * 1000);
                Console.WriteLine("Finish recipe prepare meal");
                return new Meal();
            }
        }

        internal class Meal
        {
        }

        private class Diner
        {
            internal void Give(Meal meal)
            {
                Console.WriteLine("Diner receives meal");
            }
        }

        async private static Task<Order>ObtainOrderAsync(Diner diner)
        {
            Console.WriteLine("Start obtain order");
            await Task.Delay(3 * 1000);
            Console.WriteLine("Finish obtain order");
            return new Order();
        }

        async private static Task<Ingredients>ObtainIngredientsAsync(Order order)
        {
            Console.WriteLine("Start obtain ingredients");
            await Task.Delay(2 * 1000);
            Console.WriteLine("Finish obtain ingredients");
            return new Ingredients();
        }

        async private static Task<Recipe>ObtainRecipeAsync(Order order)
        {
            Console.WriteLine("Start obtain recipe");
            await Task.Delay(5 * 1000);
            Console.WriteLine("Finish obtain recipe");
            return new Recipe();
        }

        async private static void ServeBreakfast(Diner diner)
        {
            Order order = await ObtainOrderAsync(diner);
            Ingredients ingredients = await ObtainIngredientsAsync(order);
            Recipe recipe = await ObtainRecipeAsync(order);
            Meal meal = await recipe.PrepareAsync(ingredients);
            diner.Give(meal);
        }

        static void Main(string[] args)
        {
            Diner diner = new Diner();
            ServeBreakfast(diner);
            Console.ReadLine();
        }
    }
}

Answer 1

每个Async 方法都返回一个可以被awaited 的任务。 当你调用xxxAsync 方法时，你启动了异步操作，而且，当你await 同一行的结果（即任务）时，你告诉程序“我需要这个方法的结果才能继续”。

我在您的示例中看到的唯一可以并行运行的方法是ObtainIngredientsAsync 和ObtainRecipeAsync。所有其他方法都需要以前方法的结果。

如果您希望这些提到的方法并行运行，请先调用这两个方法而不使用await，然后再调用它们await，然后再继续。

async private static void ServeBreakfast(Diner diner)
        {
            Order order = await ObtainOrderAsync(diner);
            Task<Ingredients> ingredientsTask = ObtainIngredientsAsync(order);
            Task<Recipe> recipeTask = ObtainRecipeAsync(order);
            Ingredients ingredients = await ingredientsTask;
            Recipe recipe = await recipeTask
            Meal meal = await recipe.PrepareAsync(ingredients);
            diner.Give(meal);
        }

Answer 2

你正在等待每个任务，一个接一个：

Order order = await ObtainOrderAsync(diner);
Ingredients ingredients = await ObtainIngredientsAsync(order);
Recipe recipe = await ObtainRecipeAsync(order);
Meal meal = await recipe.PrepareAsync(ingredients);
diner.Give(meal);

当您await 一个任务时，您会停止执行该方法，直到任务完成。

因此，您正在为任务定义严格的逐一顺序：在前一个任务完成之前，您不会开始任务。

这是一个示例，其中两个任务并行完成，这应该会为您提供您期望的输出。

为了（希望）使代码更清晰，我已将您的所有等待分解为单独的语句，用于创建任务并等待它们。

async private static void ServeBreakfast(Diner diner)
{
    // first task is to get the order
    Task<Order> getOrder = ObtainOrderAsync(diner);

    // we need to wait for the order, then we 
    // can get the ingredients and recipe in parallel
    Order order = await getOrder;

    // ### Change from your logic: Here we're starting two tasks in parallel. ###
    Task<Ingredients> getIngredients = ObtainIngredientsAsync(order);
    Task<Recipe> getRecipe = ObtainRecipeAsync(order);

    // once we have both the above we can make the meal
    Ingredients ingredients = await getIngredients;
    Recipe recipe = await getRecipe;
    Task<Meal> getMeal = recipe.PrepareAsync(ingredients);

    // when the meal is ready, give it to the diner
    diner.Give(await getMeal);
}