await使用中的阻塞和并发

本文讨论，通过将Lambda还原成最普通的代码段，来解释上篇提出的疑问。并更正上篇中一些不太正确的写法。最后会给出无需等待Async方法返回值时，对Async方法使用await的建议，供大家参考。
第一篇传送门：await使用中的阻塞和并发
首先我们比较以下三段代码，其中第一和第三可以做到并发执行，第二个是线性的执行。
//并发
public async Task Await3Task（）
{
var task3 = Delay3000Async（）；
var task2 = Delay2000Async（）；
var task1 = Delay1000Async（）；
await task3;
await task2;
await task1;
}
//非并发
public async Task Await3DelayAsync（）
{
await Delay3000Async（）；
await Delay2000Async（）；
await Delay1000Async（）；
}
//并发，这里甚至可以把var task3等去掉，直接调用xxxAsync（），只是会出现警告的波浪罢了
public void NoAwait3Task（）
{
var task3 = Delay3000Async（）；
var task2 = Delay2000Async（）；
var task1 = Delay1000Async（）；
}
//这里补充一下调用的三个Async方法 public async Task Delay3000Async（）
{
await Task.Delay（3000）；
Console.WriteLine（3000）；
Console.WriteLine（DateTime.Now）；
}
public async Task Delay2000Async（）
{
await Task.Delay（2000）；
Console.WriteLine（2000）；
Console.WriteLine（DateTime.Now）；
}
public async Task Delay1000Async（）
{
await Task.Delay（1000）；
Console.WriteLine（1000）；
Console.WriteLine（DateTime.Now）；
}
这里我们可以看出，await和并发木有关系，隐式的并发执行是由async方法决定的。而await是用于主动的阻塞，期望等待方法结束才继续运行时使用。
以下2个方法的执行结果是一样的，都可以并发执行。可以看出，把仅仅希望并发执行，不需要返回结果的方法丢到List里，然后Foreach是毫无意义的……所以上篇其实是干了一些蠢事情……
public void AwaitTaskList（）
{
var tasks = new List<Task>
{
Delay3000Async（），
Delay2000Async（），
Delay1000Async（）
};
tasks.ForEach（async _ => await _）；
}
public void NoAwaitTaskList（）
{
var tasks = new List<Task>
{
Delay3000Async（），
Delay2000Async（），
Delay1000Async（）
};
}

上篇提到Task在创建的时候，就已经开始运行了。而await仅仅是出现在需要等待结果的地方。所以如果无需等待，就不要写await了……貌似上篇又干了一些蠢事……
//非并发
public async Task Await3Func（）
{
Func<Task> func3 = Delay3000Async;
Func<Task> func2 = Delay2000Async;
Func<Task> func1 = Delay1000Async;
await func3（）；
await func2（）；
await func1（）；
}
//并发
public void NoAwait3Func（）
{
Func<Task> func3 = Delay3000Async;
Func<Task> func2 = Delay2000Async;
Func<Task> func1 = Delay1000Async;
func3（）；
func2（）；
func1（）；
}
同时我本人对List<Func<Task》尚未创建Task却可以并发表示疑问，接下来给出解答。下面分别贴出了使用Lambda和不使用的情况。我们可以清楚的看到Lambda表达式具体帮我们省略了什么。
//使用Lambda
public void AwaitFuncTaskList（）
{
var funcList = new List<Func<Task》（）
{
Delay3000Async,
Delay2000Async,
Delay1000Async
};
funcList.ForEach（async _ => await _（））；
}
//不使用Lambda
public void AwaitFuncTaskListNoLambda（）
{
var funcList = new List<Func<Task》（）
{
Delay3000Async,
Delay2000Async,
Delay1000Async
};
//funcList.ForEach（AwaitAction（））；
foreach（var func in funcList）
{
AwaitAction（）（func）；
}
}
public Action<Func<Task》 AwaitAction（）
{
return async _ => await _（）；
}
根据上文的总结，可以看出虽然await造成了阻塞，但并不是在主线程等待，所以我们幸运的并发了……
再看下面一段，我干脆拿掉了await,毫无疑问的并发执行了。上篇让人汗颜的事情貌似还干了不少，好在我脸皮厚，不会删掉前一篇的随笔，哈哈哈哈……
public void NoAwaitFuncTaskList（）
{
var funcList = new List<Func<Task》（）
{
Delay3000Async,
Delay2000Async,
Delay1000Async
};
funcList.ForEach（_ => _（））；
}
public void NoAwaitFuncTaskListNoLambda（）
{
var funcList = new List<Func<Task》（）
{
Delay3000Async,
Delay2000Async,
Delay1000Async
};
//funcList.ForEach（NoAwaitAction（））；
foreach（var func in funcList）
{
NoAwaitAction（）（func）；
}
}
public Action<Func<Task》 NoAwaitAction（）
{
return _ => _（）；
}
仔细看一下可以发现，为了懒惰而使用的ForEach其实增加了多余的一层Action<Func<Task》,如果直接使用foreach会是如下的情况：
public void NoAwaitFuncTaskWithoutForeachExtension（） www.yztrans.com 
{
var funcList = new List<Func<Task》（）
{
Delay3000Async,
Delay2000Async,
Delay1000Async
};
foreach （var func in funcList）
{
func（）；
}
}
接下来是总结陈述：
async用于异步，可以优美的替代Thread、BackgroundWorker和Task.Run等写法。
await用于等待。一定是在你主动希望阻塞并等待返回结果时才使用。
在async方法里，Task在创建时就开始运行了 www.lefeng123.com
写Lamdba别把自己写晕了……