微软刚刚宣布了新的C#异步特性。到目前为止我看到的所有例子都是关于从HTTP异步下载东西。肯定还有其他重要的异步任务吧？
假设我不是在写一个新的RSS客户端或Twitter应用程序。对我来说，C# Async有什么有趣之处呢？
编辑 当我观看Anders的PDC会议时，我突然有了灵感。过去我曾经参与过使用"监视器"线程编写的程序。这些线程等待某些事情发生，比如观察文件是否更改。它们并没有执行任务，只是空闲地等待，并在事件发生时通知主线程。在新模型中，这些线程可以被await/async代码所替代。
哦，这听起来很有趣。我现在还没有使用CTP，只是在审查白皮书。在看了Anders Hejlsberg的演讲之后，我认为我可以看出它如何能够证明其有用。
据我所知，async使编写异步调用更易于阅读和实现。就像现在编写迭代器一样容易（而不是手动编写功能）。这对于阻塞进程至关重要，因为在解除阻塞之前，不能执行任何有用的工作。如果您正在下载文件，则在获取该文件之前无法执行任何有用操作，浪费线程。考虑一下如何调用一个函数，您知道它将阻塞不确定的时间并返回一些结果，然后处理它（例如，在文件中存储结果）。你会怎么写呢？这里有一个简单的例子：
static object DoSomeBlockingOperation(object args)
{
// block for 5 minutes
Thread.Sleep(5 * 60 * 1000);
return args;
}
static void ProcessTheResult(object result)
{
Console.WriteLine(result);
}
static void CalculateAndProcess(object args)
{
// let's calculate! (synchronously)
object result = DoSomeBlockingOperation(args);
// let's process!
ProcessTheResult(result);
}
答案是，异步调用昂贵的函数。这样，我们不必等待阻塞操作完成。但是我们该如何做到这一点？我们会异步调用函数并注册回调函数，以便在解除阻塞时调用，以便我们可以处理结果。
static void CalculateAndProcessAsyncOld(object args)
{
// obtain a delegate to call asynchronously
Func<object, object> calculate = DoSomeBlockingOperation;
// define the callback when the call completes so we can process afterwards
AsyncCallback cb = ar =>
{
Func<object, object> calc = (Func<object, object>)ar.AsyncState;
object result = calc.EndInvoke(ar);
// let's process!
ProcessTheResult(result);
};
// let's calculate! (asynchronously)
calculate.BeginInvoke(args, cb, calculate);
}
现在调用是异步的，我们不必担心等待计算完成和处理，它是异步完成的。它会在能够完成时完成。与直接异步调用代码的替代方法是使用任务（Task）：
static void CalculateAndProcessAsyncTask(object args)
{
// create a task
Task<object> task = new Task<object>(DoSomeBlockingOperation, args);
// define the callback when the call completes so we can process afterwards
task.ContinueWith(t =>
{
// let's process!
ProcessTheResult(t.Result);
});
// let's calculate! (asynchronously)
task.Start();
}
// need to have an asynchronous version
static async Task<object> DoSomeBlockingOperationAsync(object args)
{
//it is my understanding that async will take this method and convert it to a task automatically
return DoSomeBlockingOperation(args);
}
static async void CalculateAndProcessAsyncNew(object args)
{
// let's calculate! (asynchronously)
object result = await DoSomeBlockingOperationAsync(args);
// let's process!
ProcessTheResult(result);
}
白皮书中提供了另一个实际的例子，即在UI应用程序中使用它。 修改为使用上面的示例：
private async void doCalculation_Click(object sender, RoutedEventArgs e) {
doCalculation.IsEnabled = false;
await DoSomeBlockingOperationAsync(GetArgs());
doCalculation.IsEnabled = true;
}
static async void RestartPrinter()
{
Printer printer = GetPrinter();
do
{
printer.Restart();
printer = await printer.WaitUntilReadyAsync();
} while (printer.HasFailed);
}
想象一下不使用异步操作编写循环。
我还有一个例子。假设你需要在一个函数中执行多个阻塞操作，并希望异步调用。你会选择什么？
static void DoOperationsAsyncOld()
{
Task op1 = new Task(DoOperation1Async);
op1.ContinueWith(t1 =>
{
Task op2 = new Task(DoOperation2Async);
op2.ContinueWith(t2 =>
{
Task op3 = new Task(DoOperation3Async);
op3.ContinueWith(t3 =>
{
DoQuickOperation();
}
op3.Start();
}
op2.Start();
}
op1.Start();
}
static async void DoOperationsAsyncNew()
{
await DoOperation1Async();
await DoOperation2Async();
await DoOperation3Async();
DoQuickOperation();
}
阅读白皮书，它实际上有很多实用的例子，如编写并行任务等。
我迫不及待地想开始在CTP或.NET 5.0最终发布时使用它。
BackgroundWorker比使用async和await更好。 - Brianasync 不会启动任何线程，因此你的 DoSomeVeryExpensiveCalculation() 不会在后台执行。请记住，async 用于仅运行短时间然后等待某些东西的操作。如果您想在后台运行长时间的 CPU 密集型操作，则需要显式在后台执行该操作：static Task<object> DoSomeVeryExpensiveCalculationAsync(object args)
{
return Task.Run(() => DoSomeVeryExpensiveCalculation(args));
} - Daniel主要情况是任何涉及高延迟的情况。也就是说，在“请求结果”和“获取结果”之间有很多时间。网络请求是高延迟场景最明显的例子，其次是一般的I/O操作，然后是在另一个核心上CPU绑定的长时间计算。
但是，这项技术可能还可以与其他情况良好地结合。例如，考虑编写FPS游戏的逻辑脚本。假设你有一个按钮单击事件处理程序。当玩家点击按钮时，您希望播放两秒钟的警报声以警示敌人，然后打开门十秒钟。能不能说出类似这样的话：
button.Disable();
await siren.Activate();
await Delay(2000);
await siren.Deactivate();
await door.Open();
await Delay(10000);
await door.Close();
await Delay(1000);
button.Enable();
例如，如果一个表单有一个按钮，可以打开另一个表单：
Form toolWindow;
async void button_Click(object sender, EventArgs e) {
if (toolWindow != null) {
toolWindow.Focus();
} else {
toolWindow = new Form();
toolWindow.Show();
await toolWindow.OnClosed();
toolWindow = null;
}
}
尽管如此，这并不比原来更简单
toolWindow.Closed += delegate { toolWindow = null; }
但我认为这很好地展示了await的作用。一旦事件处理程序中的代码变得非常复杂，await会使编程变得更加容易。想象一下用户需要点击一系列按钮：
async void ButtonSeries()
{
for (int i = 0; i < 10; i++) {
Button b = new Button();
b.Text = i.ToString();
this.Controls.Add(b);
await b.OnClick();
this.Controls.Remove(b);
}
}
当然，你可以使用普通的事件处理程序来完成这个任务，但这需要你拆开循环并将其转换为更难理解的形式。
请记住，await 可以用于任何在未来某个时刻完成的事物。以下是扩展方法 Button.OnClick()，使上述内容正常工作：
public static AwaitableEvent OnClick(this Button button)
{
return new AwaitableEvent(h => button.Click += h, h => button.Click -= h);
}
sealed class AwaitableEvent
{
Action<EventHandler> register, deregister;
public AwaitableEvent(Action<EventHandler> register, Action<EventHandler> deregister)
{
this.register = register;
this.deregister = deregister;
}
public EventAwaiter GetAwaiter()
{
return new EventAwaiter(this);
}
}
sealed class EventAwaiter
{
AwaitableEvent e;
public EventAwaiter(AwaitableEvent e) { this.e = e; }
Action callback;
public bool BeginAwait(Action callback)
{
this.callback = callback;
e.register(Handler);
return true;
}
public void Handler(object sender, EventArgs e)
{
callback();
}
public void EndAwait()
{
e.deregister(Handler);
}
}
不幸的是，似乎无法直接将GetAwaiter()方法添加到EventHandler中（允许使用await button.Click;），因为该方法将不知道如何注册/注销该事件。
这有点模板化，但是可以重复使用AwaitableEvent类以处理所有事件（而不仅仅是UI）。通过进行一些小修改并添加一些泛型，您可以允许检索EventArgs：
MouseEventArgs e = await button.OnMouseDown();
我认为这对于一些更复杂的UI手势（如拖放、鼠标手势等）会很有用 - 不过你需要添加取消当前手势的支持。
一个GUI时钟是一个很好的例子；假设你想画一个时钟，每秒更新一次显示的时间。从概念上讲，你需要编写
while true do
sleep for 1 second
display the new time on the clock
await（或 F# 异步）进行异步休眠，您可以编写此代码以在 UI 线程上以非阻塞方式运行。
http://lorgonblog.wordpress.com/2010/03/27/f-async-on-the-client-side/
async扩展在某些情况下非常有用，当你有一个异步操作时。异步操作具有明确的开始和完成。当异步操作完成时，它们可能具有结果或错误。（取消被视为一种特殊类型的错误）。
广义上来说，异步操作在三种情况下非常有用：
async操作。然而，这并不总是有效的；你需要首先评估你的可扩展性瓶颈。async非常适合重用。Parallel来表达，因为它们有很多内置的支持，如分区、有限并发等。一个并行操作可以通过在ThreadPool线程中运行它（Task.Factory.StartNew）轻松地包装成一个可等待的操作。这里可能是一个不好的例子，展示了如何不正确地使用新的异步特性（而不是编写新的RSS客户端或Twitter应用程序），即在虚拟方法调用中间进行重载。说实话，我不确定是否有任何方法可以创建超过一个重载点。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
namespace AsyncText
{
class Program
{
static void Main(string[] args)
{
Derived d = new Derived();
TaskEx.Run(() => d.DoStuff()).Wait();
System.Console.Read();
}
public class Base
{
protected string SomeData { get; set; }
protected async Task DeferProcessing()
{
await TaskEx.Run(() => Thread.Sleep(1) );
return;
}
public async virtual Task DoStuff() {
Console.WriteLine("Begin Base");
Console.WriteLine(SomeData);
await DeferProcessing();
Console.WriteLine("End Base");
Console.WriteLine(SomeData);
}
}
public class Derived : Base
{
public async override Task DoStuff()
{
Console.WriteLine("Begin Derived");
SomeData = "Hello";
var x = base.DoStuff();
SomeData = "World";
Console.WriteLine("Mid 1 Derived");
await x;
Console.WriteLine("EndDerived");
}
}
}
}
输出结果为：
开始派生
开始基类
你好
中间 1 派生
结束基类
世界
结束派生
在某些继承层次结构（即使用命令模式）中，我偶尔会想要做这样的事情。