以下是您可能需要执行的操作：

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 =等待c任务;变量food =等待fTask;
还有这个

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

这两种方法都将产生类似的结果，即先完成2个async任务，然后再完成return new PewPew-但是，不同之处在于Task.WaitAll()将阻塞当前线程（如果是UI线程，则UI将冻结）。相反，await将在状态机中分解SomeMethod，并在遇到await关键字时从SomeMethod返回到其调用方。它不会阻塞线程。await下面的代码将被安排在async任务结束时运行。
1.您还可以执行以下操作：
var cats =等待任务运行（（）=〉获取所有猫（foo））; var food =等待任务.运行（（）=〉获取所有食物（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);
}

到目前为止，最简单的方法是使用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()处理系统中处理器数量的扩展，但只有当您启动的不仅仅是几个任务时，这才真正重要。

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

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

您可以使用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
               };
}

再加上其他的答案，你可以这样做：

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