的问题是，当异步方法或lambda表达式返回工作或任务＆LT; T＆GT; ，他们居然穿上吨有在返回前pression外的任务类型，因为将自动为您生成的任务，方法或lambda的调用的一部分。这强烈地在我们看来是一个正确的经验，为code清晰，虽然这确实使事情完全不同之前，由于一般return语句的前pression直接转换为方法或lambda的返回类型。

所以因此，无论是异步无效 lambda表达式和异步工作 lambda表达式支持返回; 不带参数。因此，需要在方法重载澄清，以决定哪一个选择。因此，唯一的原因，你有两种运行（......）和RunEx（...）是如此，我们会确保有对异步CTP的其他部分更高质量的支持下，由当时的PDC 2010命中。

如何考虑异步方法/ lambda表达式

我不知道这是否是一个容易混淆的地方，但我想我会提到它 - 当你正在编写一个异步方法或异步拉姆达，它可以采取谁在调用它的某些特性。这是pdicated两点$ P $：

该CTP设计计谋和我们目前的内部设计都非常的模式为基础的，这样的API提供商可以帮助充实一个充满活力的一套东西，你可以等待。这可以根据上你等待的类型不同而不同，和普通类型是工作。

工作的等待执行是非常合理的，并按照当前线程的的SynchronizationContext 来决定如何推迟工作。在这你已经在一个WinForms或WPF消息循环的话，那么你的延迟执行会回来同一消息循环（因为如果你使用的BeginInvoke（）的休息的方法）。如果你等待一个任务，你就已经在.NET线程池，那么其余的方法将恢复对线程池的一个线程（但不一定是同一台完全一致），因为它们汇集到开始和最有可能你很高兴去的第一个可用的池线程。

注意有关使用wait（）的方法

在你的样品，你使用： 变种T = TaskEx.Run（（）=＆GT;测试（）等待（））;

什么，做的是：

这就是'等待'运营商的主要好处是，它可以让你增加$ C，后来执行$ C - 但没有挡住原来的线程。在线程池的情况下，可以达到更好的线程利用。

让我知道，如果您有任何关于异步CTP其他问题的VB或C＃，我很乐意听到他们的声音：）

I'm evaluating the Async CTP.

How can I begin execution of an async function on another thread pool's thread?

static async Task Test()
{
    // Do something, await something
}

static void Main( string[] args )
{
    // Is there more elegant way to write the line below?
    var t = TaskEx.Run( () => Test().Wait() );

    // Doing much more in this same thread
    t.Wait(); // Waiting for much more then just this single task, this is just an example
}

I'm new (my virginal post) to Stack Overflow, but I'm jazzed that you're asking about the Async CTP since I'm on the team working on it at Microsoft :)

I think I understand what you're aiming for, and there's a couple of things you're doing correctly, to get you there.

What I think you want:

static async Task Test()
{
    // Do something, await something
}

static void Main(string[] args)
{
    // In the CTP, use Task.RunEx(...) to run an Async Method or Async Lambda
    // on the .NET thread pool
    var t = TaskEx.RunEx(Test);
    // the above was just shorthand for
    var t = TaskEx.RunEx(new Func<Task>(Test));
    // because the C# auto-wraps methods into delegates for you.

    // Doing much more in this same thread
    t.Wait(); // Waiting for much more then just this single task, this is just an example
}

Task.Run vs. Task.RunEx

Because this CTP installs on top of .NET 4.0, we didn't want to patch the actual System.Threading.Tasks.Task type in mscorlib. Instead, the playground APIs are named FooEx when they conflicted.

Why did we name some of them Run(...) and some of the RunEx(...)? The reason is because of redesigns in method overloading that we hadn't completed yet by the time we released the CTP. In our current working codebase, we've actually had to tweak the C# method overloading rules slightly so that the right thing happens for Async Lambdas - which can return void, Task, or Task<T>.

The issue is that when async method or lambdas return Task or Task<T>, they actually don't have the outer task type in the return expression, because the task is generated for you automatically as part of the method or lambda's invocation. This strongly seems to us like the right experience for code clarity, though that does make things quite different before, since typically the expression of return statements is directly convertible to the return type of the method or lambda.

So thus, both async void lambdas and async Task lambdas support return; without arguments. Hence the need for a clarification in method overload resolution to decide which one to pick. Thus the only reason why you have both Run(...) and RunEx(...) was so that we would make sure to have higher quality support for the other parts of the Async CTP, by the time PDC 2010 hit.

How to think about async methods/lambdas

I'm not sure if this is a point of confusion, but I thought I'd mention it - when you are writing an async method or async lambda, it can take on certain characteristics of whoever is invoking it. This is predicated on two things:

The CTP design for await and our current internal design are both very pattern-based so that API providers can help flesh out a vibrant set of things that you can 'await' on. This can vary based on the type on which you're awaiting, and the common type for that is Task.

Task's await implementation is very reasonable, and defers to the current thread's SynchronizationContext to decide how to defer work. In the case that you're already in a WinForms or WPF message loop, then your deferred execution will come back on the same message loop (as if you used BeginInvoke() the "rest of your method"). If you await a Task and you're already on the .NET threadpool, then the "rest of your method" will resume on one of the threadpool threads (but not necessarily the same one exactly), since they were pooled to begin with and most likely you're happy to go with the first available pool thread.

Caution about using Wait() methods

In your sample you used: var t = TaskEx.Run( () => Test().Wait() );

What that does is:

That's the primary benefit of the 'await' operator is that it allows you to add code that executes later - but without blocking the original thread. In the thread pool case, you can achieve better thread utilization.

Let me know if you have other questions about the Async CTP for VB or C#, I'd love to hear them :)