asyns和await实现传统的异步---------C#
刚开始，我认为async方法不好理解。现在我倒觉得很好理解，并且很好用。
你不需要再用一个线程或者线程池去封装一个方法了。你只需要标明这个方法是async就可以了。
传统的异步是利用回调函数来写的，写过的人都知道，，那样写的结构东一块西一块的，很不好找。
所以在这里整理啦一下asyns和await实现的异步。。。
asyns和await的异步刚开始学的时候不是很好理解。在这里，我在注释中，将细细的标明
class Program
{
// ---------------规范说明-----------------------------
//1.用async标识的方法即为异步方法，异步方法的返回值只能是void或者Task<object>或者Task。,---返回值是void的方法，不能使用await调用。注意你的返回类型。
//2.在其他方法中调用异步方法时，可以加await，表示等待这个异步方法结束。 异步的关键点就在这个await
//3.await标签只能写在异步方法中
//4.await标识并调用的方法中，也必须要有await才行
static void Main(string[] args)
{
//第一步，写了一个 “1”
Console.WriteLine("1");
Paint();
//第三步----2，写了一个 “5”
Console.WriteLine("5");
Console.ReadLine();
}
//此方法是已经标明是异步方法
async static void Paint()
{
//第二步，写了一个“2”
Console.WriteLine("2");
//第三步--1，代码发现await字段，整个方法将直接返回， 并在这个await这里加个标签，所以第三步输出的是“5”
//等到 RequestBody方法返回值时，再次进入Paint方法中，并且直接从这个await字段处运行，
//-----------------------------等待一秒---------这时候，已经输出了“5”
//一秒后RequestBody方法返回值了，RequestBody的返回类型应该是Task<string>，
//但是，用了await之后，返回值直接就是string
//并且，输出“4”的操作被await阻塞
Console.WriteLine(await RequestBody());
Console.WriteLine("4");
}
async static Task<string> RequestBody()
{
//被await调用的方法中，必须要有await
return await Task.Run(() =>
{
Thread.Sleep(2000);
return "3";
});
}
}2016-1-11补充：其实上面的理解比较浅，关于异步函数的返回值有几种类型。是有错的。还有一种类型，是Task，就是本身
下面是我在书上看到的demo，是关于如何给异步函数限定运行时间的。超时之后，异步函数将被取消
第一步，写一个类，里面放拓展方法
public static class CancelTask
{
private struct Void { }
public static async Task<TResult> WithCancellation<TResult>(this Task<TResult> originalTask, CancellationToken ct)
{
var cancellTask = new TaskCompletionSource<Void>();
using (ct.Register(t => ((TaskCompletionSource<Void>)t).TrySetResult(new Void()), cancellTask))
{
Task any = await Task.WhenAny(originalTask, cancellTask.Task);
if (any == cancellTask.Task)
{
ct.ThrowIfCancellationRequested();
}
return await originalTask;
}
}
//这个方法不需要显示的写return
public static async Task WithCancellation(this Task originalTask, CancellationToken ct)
{
var cancellTask = new TaskCompletionSource<Void>();
using (ct.Register(t => ((TaskCompletionSource<Void>)t).TrySetResult(new Void()), cancellTask))
{
Task any = await Task.WhenAny(originalTask, cancellTask.Task);
if (any == cancellTask.Task)
{
ct.ThrowIfCancellationRequested();
}
}
await originalTask;
//这里是可以无返回值的
}
}第二部，写一个log类。书上的log类写的好复杂。我看完瞎了眼。所以你只需要知道它是个log类，给你看运行效果的。软件发布时，不需要它
public static class TaskLogger
{
public enum TaskLogLevel { None, Pending }
public static TaskLogLevel LogLevel { get; set; }
public sealed class TaskLogEntry
{
public Task Task { get; set; }
public string Tag { get; set; }
public DateTime LogTime { get; set; }
public string CallerMemberName { get; set; }
public string CallerFilePath { get; set; }
public Int32 CallerLineNumber { get; set; }
public override string ToString()
{
return String.Format("LogTime={0},Tag={1},Member={2},File={3}({4})", LogTime, Tag ?? "(none)", CallerMemberName, CallerFilePath, CallerLineNumber);
}
}
private static readonly ConcurrentDictionary<Task, TaskLogEntry> s_Log = new ConcurrentDictionary<Task, TaskLogEntry>();
public static IEnumerable<TaskLogEntry> GetLogEntries() { return s_Log.Values; }
public static Task<TResult> Log<TResult>(this Task<TResult> task, string tag = null,
[CallerMemberName]String callerMemberName = null, [CallerFilePath]String callerfilepath = null,
[CallerLineNumber] Int32 callerlinenumber = -1)
{
return (Task<TResult>)
Log((Task)task, tag, callerMemberName, callerfilepath, callerlinenumber);
}
public static Task Log(this Task task, string tag = null,
[CallerMemberName]String callerMemberName = null, [CallerFilePath]String callerfilepath = null,
[CallerLineNumber] Int32 callerlinenumber = -1)
{
if (LogLevel == TaskLogLevel.None) return task;
var logEntry = new TaskLogEntry
{
Task = task,
LogTime = DateTime.Now,
Tag = tag,
CallerLineNumber = callerlinenumber,
CallerFilePath = callerfilepath,
CallerMemberName = callerMemberName
};
s_Log[task] = logEntry;
task.ContinueWith(t => { TaskLogEntry entry; s_Log.TryRemove(t, out entry); }, TaskContinuationOptions.ExecuteSynchronously);
return task;
}第三部，写一个Go（）方法
class Program
{
static void Main(string[] args)
{
Go();
Console.ReadKey();
}
public static async Task Go()
{
#if DEBUG
//使用TaskLogger会影响内存和性能，所以只在调试生成中使用它
TaskLogger.LogLevel = TaskLogger.TaskLogLevel.Pending;
#endif
//初始化3个任务，为了测试TaskLogger，我们显示控制其持续时间
var tasks = new List<Task>
{
//delay的意思是延迟。意思是，如果这个task只用1秒钟就完成了操作。。这里可以延迟到两秒钟或者更久去结束它
Task.Delay(2000).Log("2s op"),
Task.Delay(5000).Log("5s op"),
Task.Delay(6000).Log("6s op"),
};
try
{
//等待全部任务，但在3秒后取消；只有一个任务能按时完成
//注意：WithCancellation扩展方法的两个重载版本
await Task.WhenAll(tasks).WithCancellation(new CancellationTokenSource(3000).Token);
foreach (var op in TaskLogger.GetLogEntries().OrderBy(tle => tle.LogTime))
{
Console.WriteLine(op);
}
}
catch (OperationCanceledException)
{
foreach (var op in TaskLogger.GetLogEntries().OrderBy(tle => tle.LogTime))
{
Console.WriteLine(op);
}
}
}
}总结一下：关于async和await的关系。
1.给方法前加async后，调用方法时，方法会异步执行，就像在一个线程里面执行一样。 但是，你要是用await调用async方法的话。，这个async方法就会同步执行。会阻塞它后面的操作。
2.async方法可以用三种返回类型。
Task<T>,这个可以返回一个有用的T类型，比如一个string
Task，这些写的时候，方法不能显示的写return，方法会自动返回自身（是不是隐式的返回自身，这个我自己未验证。做到这一步，我是猜的。。你调试的时候，
看下上面WithCancellation方法的返回值就可以知道我猜的对不对了）
void，（这种返回类型我没写过，你自己看着研究）