如何在 .NET 4.5 中“同时”运行这两种方法？

Question

我有一个方法可以执行 2 个独立 逻辑。我希望我可以同时运行它们 .. 并且只有在这两个子方法都完成后才能继续。

我试图理解 async/await 语法，但我就是不明白。

代码如下：

public PewPew SomeMethod(Foo foo)
{
    var cats = GetAllTheCats(foo);
    var food = GetAllTheFood(foo);

    return new PewPew
               {
                   Cats = cats,
                   Food = food
               };
}

private IList<Cat> GetAllTheCats(Foo foo)
{
    // Do stuff, like hit the Db, spin around, dance, jump, etc...
    // It all takes some time.
    return cats;
}

private IList<Food> GetAllTheFood(Foo foo)
{
    // Do more stuff, like hit the Db, nom nom noms...
    // It all takes some time.
    return food;
}

因此，使用上面的代码，我想说：去同时获取所有的猫和食物。完成后，返回一个新的PewPew。

我很困惑，因为我不确定上面的哪些类是 async 或返回 Task 等等。全部？只有两个私人的？我也猜想我需要利用 Task.WaitAll(tasks) 方法，但我不确定如何设置任务同时运行。

建议，好心人？

Answer 1

这是您可能想要做的事情：

public async Task<PewPew> SomeMethod(Foo foo)
{
    // get the stuff on another thread 
    var cTask = Task.Run(() => GetAllTheCats(foo));
    var fTask = Task.Run(() => GetAllTheFood(foo));

    var cats = await cTask;
    var food = await fTask;

    return new PewPew
               {
                   Cats = cats,
                   Food = food
               };
}

public IList<Cat> GetAllTheCats(Foo foo)
{
    // Do stuff, like hit the Db, spin around, dance, jump, etc...
    // It all takes some time.
    return cats;
}

public IList<Food> GetAllTheFood(Foo foo)
{
    // Do more stuff, like hit the Db, nom nom noms...
    // It all takes some time.
    return food;
}

这里有两点你需要了解：

1) 这之间有什么区别：

var cats = await cTask;
var food = await fTask;

还有这个：

Task.WaitAll(new [] {cTask, fTask});

两者都会给你类似的结果，让 2 个async 任务完成然后return new PewPew - 但是，不同之处在于Task.WaitAll() 将阻塞当前线程（如果那是 UI 线程，那么 UI 将冻结）。相反，await 将在状态机中分解SomeMethod，并在遇到await 关键字时从SomeMethod 返回给它的调用者。它不会阻塞线程。 await 下面的代码将安排在async 任务结束时运行。

2) 你也可以这样做：

var cats = await Task.Run(() => GetAllTheCats(foo));
var food = await Task.Run(() => GetAllTheFood(foo));

但是，这不会同时启动async 任务。第二个任务将在第一个任务结束后开始。这是因为await 关键字的工作原理，希望对您有所帮助...

编辑：如何使用SomeMethod - 在调用树的开始处，你必须使用Wait() 或Result 属性 - 或者 - 你必须从async void 使用await。 通常，async void 将是一个事件处理程序：

public async void OnSomeEvent(object sender, EventArgs ez) 
{ 
  Foo f = GetFoo();
  PewPew p = await SomeMethod(f);
}

如果没有，则使用Result 属性。

public Foo2 NonAsyncNonVoidMethod() 
{
   Foo f = GetFoo();
   PewPew p = SomeMethod(f).Result; //But be aware that Result will block thread

   return GetFoo2(p);
}

Answer 2

到目前为止，最简单的方法是使用Parallel.Invoke()

IList<Cat> cats;
IList<Food> food;

Parallel.Invoke
(
    () => cats = GetAllTheCats(foo),
    () => food = GetAllTheFood(foo)
);

Parallel.Invoke() 将等待所有方法返回，然后自己返回。

更多信息在这里：http://msdn.microsoft.com/en-us/library/dd460705.aspx

请注意，Parallel.Invoke() 会根据系统中的处理器数量进行扩展，但这仅在您启动的任务不止几个时才真正重要。

Answer 3

如果您没有使用异步方法，或者您使用的是旧版本的 .Net 框架，则不必使用异步。为简单起见，只需使用 Tasks： p>

Task taskA = Task.Factory.StartNew(() => GetAllTheCats(foo));
Task taskB = Task.Factory.StartNew(() => GetAllTheFood(foo));

Task.WaitAll(new [] { taskA, taskB });
// Will continue after both tasks completed

Answer 4

除了其他答案，您可以执行以下操作：

public PewPew SomeMethod(Foo foo)
{
    Task<IList<Cat>> catsTask = GetAllTheCatsAsync(foo);
    Task<IList<Food>> foodTask = GetAllTheFoodAsync(foo);

    // wait for both tasks to complete
    Task.WaitAll(catsTask, foodTask);

    return new PewPew
    {
        Cats = catsTask.Result,
        Food = foodTask.Result
    };
}

public async Task<IList<Cat>> GetAllTheCatsAsync(Foo foo)
{
    await Task.Delay(7000); // wait for a while
    return new List<Cat>();
}

public async Task<IList<Food>> GetAllTheFoodAsync(Foo foo)
{
    await Task.Delay(5000); // wait for a while
    return new List<Food>();
}

Answer 5

您可以使用TPL 在多个任务运行时等待它们。见here。

像这样：

public PewPew SomeMethod(Foo foo) {
    IList<Cat> cats = null;
    IList<Food> foods = null;

    Task[] tasks = new tasks[2] {
        Task.Factory.StartNew(() => { cats = GetAllTheCats(foo); }),
        Task.Factory.StartNew(() => { food = GetAllTheFood(foo); })
    };

    Task.WaitAll(tasks);

    return new PewPew
               {
                   Cats = cats,
                   Food = food
               };
}