 上传我的文档
 下载
 收藏
该文档贡献者很忙，什么也没留下。
 下载此文档
正在努力加载中...
转载 C 异步委托的用法
下载积分：400
内容提示：转载 C 异步委托的用法
　　 每个委托都有..
文档格式：PDF|
浏览次数：38|
上传日期： 12:16:23|
文档星级：
该用户还上传了这些文档
转载 C 异步委托的用法
官方公共微信您的位置： >
C#中BeginInvoke与EndInvoke
学习标签：
本文导读：C#中BeginInvoke方法可以使用线程异步地执行委托所指向的方法。然后通过EndInvoke方法获得方法的返回值（EndInvoke方法的返回值就是被调用方法的返回值），或是确定方法已经被成功调用。当使用BeginInvoke异步调用方法时，如果方法未执行完，EndInvoke方法就会一直阻塞，直到被调用的方法执行完毕。
普通方法运行，是单线程的，如果中途有大型操作（如：读取大文件，大批量操作数据库，网络传输等），都会导致方法阻塞，表现在界面上就是，程序卡或者死掉，界面元素不动了，不响应了。
异步方法很好的解决了这些问题，异步执行某个方法，程序立即开辟一个新线程去运行你的方法，主线程包括界面就不会死掉了。
异步调用并不是要减少线程的开销, 它的主要目的是让调用方法的主线程不需要同步等待在这个函数调用上, 从而可以让主线程继续执行它下面的代码.
在C#中使用线程的方法很多，使用委托的BeginInvoke和EndInvoke方法就是其中之一。BeginInvoke方法可以使用线程异步地执行委托所指向的方法。然后通过EndInvoke方法获得方法的返回值（EndInvoke方法的返回值就是被调用方法的返回值），或是确定方法已经被成功调用。
一、BeginInvoke方法
用于启动异步调用
public IAsyncResult BeginInvoke(&输入和输出变量&,回调函数callback , 附加信息AsyncState)
2、函数返回值类型
public interface IAsyncResult
object AsyncState...{ get;}
//如果有回调函数的话该参数用于保存要传递给回调函数的参数值
WaitHandle AsyncWaitHandle...{ get;}
bool CompletedSynchronously...{ get;}
bool IsCompleted...{ get;} //保存方法是否执行结束，我们可以通过该属性的值来判断异步方法是否执行结束
(1).BeginInvoke返回IasyncResult，可用于监视调用进度。
(2).结果对象IAsyncResult是从开始操作返回的，并且可用于获取有关异步开始操作是否已完成的状态。
(3).结果对象被传递到结束操作，该操作返回调用的最终返回值。
(4).在开始操作中可以提供可选的回调。如果提供回调，在调用结束后，将调用该回调；并且回调中的代码可以调用结束操作。
(5).如果需要将一些额外的信息传送给回调函数，就将其放入BeginInvoke()方法的第3个参数asyncState中。注意到这个参数的类型为Object，所以可以放置任意类型的数据。如果有多个信息需要传送给回调函数，可以将所有要传送的信息封状到一个Struct变量，或者干脆再定义一个类，将信息封装到这个类所创建的对象中，再传送给BeginInvoke()方法。
二、EndInvoke方法
用于检索异步调用结果
public &方法返回值类型&EndInvoke(&声明为ref或out的参数&, IAsyncResult result )
(1).result参数由BeginInvoke()方法传回。.NET借此以了解方法调用是否完成。
(2).当EndInvoke方法发现异步调用完成时，它取出此异步调用方法的返回值作为其返回值，如果异步调用方法有声明为ref和out的参数，它也负责填充它。
(3).在调用BeginInvoke后可随时调用EndInvoke方法,注意：始终在异步调用完成后调用EndInvoke。
(4).如果异步调用未完成，EndInvoke将一直阻塞到异步调用完成。
(5).EndInvoke的参数包括需要异步执行的方法的out和ref参数以及由BeginInvoke返回的IAsyncResult。 &
三、BeginInvoke与EndInvoke实例
1、直接使用EndInvoke方法来获得返回值
当使用BeginInvoke异步调用方法时，如果方法未执行完，EndInvoke方法就会一直阻塞，直到被调用的方法执行完毕。如下面的代码所示：
C# 代码 &&复制
using System.Collections.G
using System.L
using System.T
using System.T
namespace ConsoleApplication1
class Program
private static int newTask(int ms)
Console.WriteLine(&任务开始&);
Thread.Sleep(ms);
Random random = new Random();
int n = random.Next(<span style="color: #000);
Console.WriteLine(&任务完成&);
private delegate int NewTaskDelegate(int ms);
static void Main(string[] args)
NewTaskDelegate task = newT
IAsyncResult asyncResult = task.BeginInvoke(<span style="color: #00, null, null);
// EndInvoke方法将被阻塞2秒
int result = task.EndInvoke(asyncResult);
Console.WriteLine(result);
(1)、在运行上面的程序后，由于newTask方法通过Sleep延迟了2秒，因此，程序直到2秒后才输出最终结果（一个随机整数）。
(2)、如果不调用EndInvoke方法，程序会立即退出，这是由于使用BeginInvoke创建的线程都是后台线程，这种线程一但所有的前台线程都退出后（其中主线程就是一个前台线程），不管后台线程是否执行完毕，都会结束线程，并退出程序。
2、使用轮询等待异步调用完成：使用IAsyncResult的IsCompleted属性来判断异步调用是否完成
当调用EndInvoke方法获得调用结果时，整个程序就象死了一样，依然要等待异步方法执行结束，这样做用户的感觉并不会太好，因此，我们可以使用 asyncResult来判断异步调用是否完成，并显示一些提示信息。这样做可以增加用户体验。
C# 代码 &&复制
using System.Collections.G
using System.T
using System.IO;
namespace AsyncCalculateFolderSize2
class Program
//计算指定文件夹的总容量
private static long CalculateFolderSize(string FolderName)
if (Directory.Exists(FolderName) == false)
throw new DirectoryNotFoundException(&文件夹不存在&);
DirectoryInfo RootDir = new DirectoryInfo(FolderName);
//获取所有的子文件夹
DirectoryInfo[] ChildDirs = RootDir.GetDirectories();
//获取当前文件夹中的所有文件
FileInfo[] files = RootDir.GetFiles();
long totalSize = <span style="color: #;
//累加每个文件的大小
foreach (FileInfo file in files)
totalSize += file.L
//对每个文件夹执行同样的计算过程：累加其下每个文件的大小
//这是通过递归调用实现的
foreach (DirectoryInfo dir in ChildDirs)
totalSize += CalculateFolderSize(dir.FullName);
//返回文件夹的总容量
return totalS
//定义一个委托
public delegate long CalculateFolderSizeDelegate(string FolderName);
static void Main(string[] args)
//定义一个委托变量引用静态方法CalculateFolderSize
CalculateFolderSizeDelegate d = CalculateFolderS
Console.WriteLine(&请输入文件夹名称(例如:C:\\\\Windows):&);
string FolderName = Console.ReadLine();
//通过委托异步调用静态方法CalculateFolderSize
IAsyncResult ret = d.BeginInvoke(FolderName, null, null);
Console.Write (&正在计算中，请耐心等待&);
//每隔2秒检查一次,输出一个&.&
while (ret.IsCompleted == false)
Console.Write(&.&);
System.Threading.Thread.Sleep(<span style="color: #0);
//阻塞，等到调用完成，取出结果
long size = d.EndInvoke(ret);
Console.WriteLine(&\\n计算完成!\\n文件夹{0}的容量为:{1}字节&, FolderName, size);
3、使用轮询等待异步调用完成：使用IAsyncResult的AsyncWaitHandle.WaitOne
C# 代码 &&复制
using System.Collections.G
using System.L
using System.T
using System.IO;
namespace AsyncCalculateFolderSize3
class Program
//计算指定文件夹的总容量
private static long CalculateFolderSize(string FolderName)
if (Directory.Exists(FolderName) == false)
throw new DirectoryNotFoundException(&文件夹不存在&);
DirectoryInfo RootDir = new DirectoryInfo(FolderName);
//获取所有的子文件夹
DirectoryInfo[] ChildDirs = RootDir.GetDirectories();
//获取当前文件夹中的所有文件
FileInfo[] files = RootDir.GetFiles();
long totalSize = <span style="color: #;
//累加每个文件的大小
foreach (FileInfo file in files)
totalSize += file.L
//对每个文件夹执行同样的计算过程：累加其下每个文件的大小
//这是通过递归调用实现的
foreach (DirectoryInfo dir in ChildDirs)
totalSize += CalculateFolderSize(dir.FullName);
//返回文件夹的总容量
return totalS
//定义一个委托
public delegate long CalculateFolderSizeDelegate(string FolderName);
static void Main(string[] args)
//定义一个委托变量引用静态方法CalculateFolderSize
CalculateFolderSizeDelegate d = CalculateFolderS
Console.WriteLine(&请输入文件夹名称(例如:C:\\\\Windows):&);
string FolderName = Console.ReadLine();
//通过委托异步调用静态方法CalculateFolderSize
IAsyncResult ret = d.BeginInvoke(FolderName, null, null);
Console.Write(&正在计算中，请耐心等待&);
while(!ret.AsyncWaitHandle.WaitOne(<span style="color: #00))
//等待2秒钟，输出一个&.&
Console.Write(&.&);
//阻塞，等到调用完成，取出结果
long size = d.EndInvoke(ret);
Console.WriteLine(&\\n计算完成。文件夹{0}的容量为:{1}字节\\n&, FolderName, size);
WaitOne的第一个参数表示要等待的毫秒数，在指定时间之内，WaitOne方法将一直等待，直到异步调用完成，并发出通知，WaitOne方法才返回true。当等待指定时间之后，异步调用仍未完成，WaitOne方法返回false，如果指定时间为0，表示不等待，如果为-1，表示永远等待，直到异步调用完成。
4、使用回调方式返回结果
要想在调用的过程中，程序仍然可以正常做其它的工作，就必须使用异步调用的方式。
C# 代码 &&复制
private delegate int MyMethod();
private int method()
Thread.Sleep(<span style="color: #000);
return <span style="color: #0;
private void MethodCompleted(IAsyncResult asyncResult)
if (asyncResult == null) return;
textBox1.Text = (asyncResult.AsyncState as
MyMethod).EndInvoke(asyncResult).ToString();
private void button1_Click(object sender, EventArgs e)
MyMethod my =
IAsyncResult asyncResult = my.BeginInvoke(MethodCompleted, my);
这里使用了BeginInvoke方法的最后两个参数（如果被调用的方法含有参数的话，这些参数将作为BeginInvoke的前面一部分参数，如果没有参数，BeginInvoke就只有两个参数了）。
第一个参数是回调方法委托类型，这个委托只有一个参数，就是IAsyncResult,如MethodCompleted方法所示。当method方法执行完后，系统会自动调用MethodCompleted方法。
BeginInvoke的第二个参数需要向MethodCompleted方法中传递一些值，一般可以传递被调用方法的委托，如上面代码中的my。这个值可以使用IAsyncResult.AsyncState属性获得。
四、BeginInvoke与EndInvoke完整实例
C# 代码 &&复制
using System.Collections.G
using System.L
using System.T
using System.T
namespace ConsoleApplication1
public delegate void AsynComputeCaller(int num, out int result);
class Factorial
public int Compute(int num)
Thread.Sleep(new Random().Next(<span style="color: #0,<span style="color: #9));
if (num == <span style="color: #) return <span style="color: #;
return num * this.Compute(num - <span style="color: #);
/**//// &summary&
/// 异步计算阶乘
/// &/summary&
/// &param name=&num&&&/param&
/// &param name=&result&&&/param&
public void AsynCompute(int num, out int result)
Console.WriteLine(&\\n
AsynCompute...start&);
DateTime startTime = DateTime.N
result = this.Compute(num);
DateTime endTime = DateTime.N
Console.WriteLine(&\\n
AsynCompute...end(Milliseconds Used:{0})&,
endTime.Subtract(startTime).Milliseconds);
class Program
int result = <span style="color: #;
/**//// &summary&
/// 调用BeginInvoke方法启动异步方法，
/// 进行某些操作，
/// 然后调用EndInvoke方法来一直阻止请求线程到调用完成。
/// &/summary&
void Run()
Factorial f = new Factorial();
AsynComputeCaller caller = new AsynComputeCaller(f.AsynCompute);
Console.WriteLine(&Run...start&);
IAsyncResult iAsyncResult = caller.BeginInvoke(<span style="color: #, out result, null, null);
//主线程进行一些操作
Console.WriteLine(&
主线程进行一些操作&);
for (int i = <span style="color: #; i & <span style="color: #; i++)
Thread.Sleep(<span style="color: #);
Console.Write(&.&);
Console.WriteLine();
//调用EndInvoke来等待异步调用结束，并获得结果
caller.EndInvoke(out result, iAsyncResult);
Console.Write(&Run...end(result:{0})&, result);
/**//// &summary&
/// 调用BeginInvoke方法启动异步方法，
/// 使用System.IAsyncResult.AsyncWaitHandle属性获取WaitHandle，
/// 使用它的WaitOne方法一直阻止执行直到发出WaitHandle信号，
/// 然后调用EndInvoke方法。
/// &/summary&
void Run2()
Factorial f = new Factorial();
AsynComputeCaller caller = new AsynComputeCaller(f.AsynCompute);
Console.WriteLine(&Run...start&);
IAsyncResult iAsyncResult = caller.BeginInvoke(<span style="color: #, out result, null, null);
//主线程进行一些操作
Console.WriteLine(&
主线程进行一些操作&);
for (int i = <span style="color: #; i & <span style="color: #; i++)
Thread.Sleep(<span style="color: #);
Console.Write(&.&);
Console.WriteLine();
Console.WriteLine(&
等待WaitHandle接收到信号&);
//等待WaitHandle接收到信号
iAsyncResult.AsyncWaitHandle.WaitOne();
caller.EndInvoke(out result, iAsyncResult);
Console.Write(&Run...end(result:{0})&, result);
/**//// &summary&
/// 调用BeginInvoke方法启动异步方法，
/// 轮询由BeginInvoke返回的IAsyncResult，
/// 确定异步调用何时完成，
/// 然后调用EndInvoke。
/// &/summary&
void Run3()
Factorial f = new Factorial();
AsynComputeCaller caller = new AsynComputeCaller(f.AsynCompute);
Console.WriteLine(&Run...start&);
IAsyncResult iAsyncResult = caller.BeginInvoke(<span style="color: #, out result, null, null);
//主线程进行一些操作
Console.WriteLine(&
主线程进行一些操作&);
while(!iAsyncResult.IsCompleted)
Thread.Sleep(<span style="color: #0);
Console.Write(&.&);
Console.WriteLine();
Console.WriteLine(&
异步方法已经结束&);
//等待WaitHandle接收到信号
iAsyncResult.AsyncWaitHandle.WaitOne();
caller.EndInvoke(out result, iAsyncResult);
Console.Write(&Run...end(result:{0})&, result);
/**//// &summary&
/// 调用BeginInvoke方法启动异步方法时，
/// 将代表异步方法完成时需要回调的方法的委托传递给BeginInvoke。
/// 异步调用完成后，将在ThreadPool线程上执行该回调方法。
/// 在该回调方法中调用EndInvoke。
/// &/summary&
void Run4()
Factorial f = new Factorial();
AsynComputeCaller caller = new AsynComputeCaller(f.AsynCompute);
Console.WriteLine(&Run...start&);
IAsyncResult iAsyncResult = caller.BeginInvoke(<span style="color: #, out result,
new AsyncCallback(CallbackMethod), caller);
//主线程进行一些操作
Console.WriteLine(&
主线程进行一些操作&);
for (int i = <span style="color: #; i & <span style="color: #; i++)
Thread.Sleep(<span style="color: #);
Console.Write(&.&);
Console.WriteLine();
void CallbackMethod(IAsyncResult ar)
AsynComputeCaller caller = (AsynComputeCaller)ar.AsyncS
caller.EndInvoke(out result, ar);
Console.Write(&Run...end(result:{0})&, result);
static void Main(string[] args)
Program p = new Program();
Console.WriteLine(&\\n\\n*** Run ***&);
Console.WriteLine(&\\n\\n*** Run2 ***&);
Console.WriteLine(&\\n\\n*** Run3 ***&);
Console.WriteLine(&\\n\\n*** Run4 ***&);
Console.Read();
五、BeginInvoke与Invoke的区别
1、Invoke() 调用时，会阻塞当前线程，等到 Invoke() 方法返回才继续执行后面的代码，表现出&同步&的概念。
2、BeginInvoke() 调用时，当前线程会启用线程池中的某个线程来执行此方法，当前线程不被阻塞，继续运行后面的代码，表现出&异步&的概念。
3、EndInvoke() ，在想获取 BeginInvoke() 执行完毕后的结果时，调用此方法来获取。
您可能感兴趣
一月好评排行榜您当前位置：&&&&&&&&&
售前咨询热线
异步编程In .NET:APM/EAP和async/await
大势至公司网络管理软件、公司网管必备软件列表
概述在之前写的一篇关于async和await的前世今生的文章之后，大家似乎在async和await提高网站处理能力方面还有一些疑问，博客园本身也做了不少的尝试。今天我们再来回答一下这个问题，同时我们会做一个async和await在WinForm中的尝试，并且对比在4.5之前的异步编程模式APM/EAP和async/await的区别，最后我们还会探讨在不同线程之间交互的问题。IIS存在着处理能力的问题，但是WinForm却是UI响应的问题，并且WinForm的UI线程至始至终都是同一个，所以两者之间有一定的区别。有人会问，现在还有人写WinForm吗？好吧，它确是一个比较老的东西呢，不如WPF炫，技术也不如WPF先进，但是从架构层面来讲，不管是Web，还是WinForm，又或是WPF，Mobile，这些都只是表现层，不是么？现在的大型系统一般桌面客户端，Web端，手机，平板端都会涉及，这也是为什么会有应用层，服务层的存在。我们在这谈论的ASP.NET MVC，WinForm，WFP，Android/IOS/WP 都是表现层，在表现层我们应该只处理与&表现&相关的逻辑，任何与业务相关的逻辑应该都是放在下层处理的。关于架构的问题，我们后面再慢慢深入，另外别说我没有提示您，我们今天还会看到.NET中另一个已经老去的技术Web Service。还得提示您，文章内容有点长，涉及的知识点比较多，所以，我推荐：&先顶后看& ，先顶后看是21世纪看长篇的首选之道，是良好沟通的开端，想知道是什么会让你与众不同吗？想知道为什么上海今天会下这么大的雨么？请记住先顶后看，你顶的不是我的文章，而是我们冒着大雨还要去上班的可贵精神！先顶后看，你值得拥有！async/await如何提升IIS处理能力首先响应能力并不完全是说我们程序性能的问题，有时候可能你的程序没有任何问题，而且精心经过优化，可是响应能力还是没有上去，网站性能分析是一个复杂的活，有时候只能靠经验和不断的尝试才能达到比较好的效果。当然我们今天讨论的主要是IIS的处理能力，或者也可能说是IIS的性能，但绝非代码本身的性能。即使async/await能够提高IIS的处理能力，但是对于用户来说整个页面从发起请求到页面渲染完成的这些时间，是不会因为我们加了async/await之后产生多大变化的。另外异步的ASP.NET并非只有async/await才可以做的，ASP.NET在Web Form时代就已经有异步Page了，包括ASP.NET MVC不是也有异步的Controller么？async/await 很新，很酷，但是它也只是在原有一技术基础上做了一些改进，让程序员们写起异步代码来更容易了。大家常说微软喜欢新瓶装旧酒，至少我们要看到这个新瓶给我们带来了什么，不管是任何产品，都不可能一开始就很完美，所以不断的迭代更新，也可以说是一种正确做事的方式。ASP.NET并行处理的步骤ASP.NET是如何在IIS中工作的一文已经很详细的介绍了一个请求是如何从客户端到服务器的HTTP.SYS最后进入CLR进行处理的（强烈建议不了解这一块的同学先看这篇文章，有助于你理解本小节），但是所有的步骤都是基于一个线程的假设下进行的。IIS本身就是一个多线程的工作环境，如果我们从多线程的视角来看会发生什么变化呢？我们首先来看一下下面这张图。注意：我们下面的步骤是建立在IIS7.0以后的集成模式基础之上的。我们再来梳理一下上面的步骤：
所有的请求最开始是由HTTP.SYS接收的，HTTP.SYS内部有一个队列维护着这些请求，这个队列的request的数量大于一定数量（默认是1000）的时候，HTTP.SYS就会直接返回503状态（服务器忙），这是我们的第一个阀门。
HTTP.SYS把请求交给CLR 线程池中的IO线程
CLR 线程池中的&Worker线程从IO线程中接过请求来处理，IO线程不必等待该请求的处理结果，而是可以返回继续去处理HTTP.SYS队列中的请求。IO线程和Worker线程的数量上限是第二个阀门。
当CLR中正在被处理的请求数据大于一定值（最大并行处理请求数量）的时候，从IO线程过来的请求就不会直接交给Worker线程，而是放到一个进程池级别的一个队列了，等到这个数量小于临界值的时候，才会把它再次交给Worker线程去处理。这是我们的第三个阀门。哪些因素会控制我们的响应能力从上面我们提到了几大阀门中，我们可以得出下面的几个数字控制或者说影响着我们的响应能力。
HTTP.SYS队列的长度
最大IO线程数量和最大Worker线程数量
最大并行处理请求数量HTTP.SYS队列的长度这个我觉得不需要额外解释，默认值是1000。这个值取决于我们我们后面CLR IO线程和Worker线程的处理速度，如果它们两个都处理不了，这个数字再大也没有用。因为最后他们会被存储到进程池级别的队列中，所以只会造成内存的浪费。最大IO线程数量和最大Worker线程数量这两个值是可以在web.config中进行配置的。maxIoThreads: 从HTTP.SYS队列中拿请求的最大IO线程数量maxWorkerThreads: CLR中真实处理请求的最大Worker线程数量minIoThreads:&从HTTP.SYS队列中拿请求的最小IO线程数量minWorkerThreads:CLR中真实处理请求的最小Worker线程数量minIoThreads和minWorkerThreads的默认值是1，合理的加大他们可以避免不必要的线程创建和销毁工作。maxIoThreads如果设置太大的话，或者说不合理的话就会导致多数的request被放到进程池级别的队列中。所以 maxIoThreads和maxWorkerThreads是有一定关系的，假设1个worker线程1s可以处理10个请求，如果我们的机器配置只允许我们同时处理100个请求，那我们合理的maxThreads就是10。但是IO线程并不需要10s去处理一个请求，它比woker线程快，因为它只要从HTTP.SYS的队列那里拿过来就可以了，我们假设一个IO线程1s可以处理20个请求，对应100个请求的上限，那我们maxIoThreads的合理值应该是5。最大并行处理请求数量进程池级别的队列给我们的CLR一定的缓冲，这里面要注意的是，这个队列还没有进入到CLR，所以它不会占用我们托管环境的任何资源，也就是把请求卡在了CLR的外面。我们需要在aspnet.config级别进行配置，我们可以在.net fraemwork的安装目录下找到它。一般是&C:\Windows\Microsoft.NET\Framework\v4.0.30319 如果你安装的是4.0的话。maxConcurrentRequestPerCPU: 每个CPU所允许的最大并行处理请求数量，当CLR中worker线程正在处理的请求之和大于这个数时，从IO线程过来的请求就会被放到我们进程池级别的队列中。maxConcurrentThreadsPerCPU: 设置为0即禁用。requestQueueLimit：这个就是我们HTTP.SYS中队列的那个长度，我们可以在web.config/system.web/processModel结点下配置。async和await 做了什么？我们终于要切入正题了，拿ASP.NET MVC举例，如果不采用async的Action，那么毫无疑问，它是在一个Woker线程中执行的。当我们访问一些web service，或者读文件的时候，这个Worker线程就会被阻塞。假设我们这个Action执行时间一共是100ms，其它访问web service花了80ms，理想情况下一个Worker线程一秒可以响应10个请求，假设我们的maxWorkerThreads是10，那我们一秒内总是可响应请求就是100。如果说我们想把这个可响应请求数升到200怎么做呢？有人会说，这还不简单，把maxWorkerThreads调20不就行了么？ 其实我们做也没有什么 问题，确实是可以的，而且也确实能起到作用。那我们为什么还要大费周章的搞什么 async/await呢？搞得脑子都晕了？async/await给我们解决了什么问题？它可以在我们访问web service的时候把当前的worker线程放走，将它放回线程池，这样它就可以去处理其它的请求了。和IO线程一样，IO线程只负责把请求交给Worker线程或者放入进程池级别的队列，然后又去HTTP.SYS的队列中处理其它的请求。等到web service给我们返回结果了，会再到线程池中随机拿一个新的woker线程继续往下执行。也就是说我们减少了那一部分等待的时间，充份利用了线程。我们来对比一下使用async/awit和不使用的情况，不使用async/await：&20个woker线程1s可以处理200个请求。那转换成总的时间的就是 20 * 1000ms = &20000ms，其中等待的时间为 200 * 80ms = 16000ms。也就是说使用async/await我们至少节约了16000ms的时间，这20个worker线程又会再去处理请求，即使按照每个请求100ms的处理时间我们还可以再增加160个请求。而且别忘了100ms是基于同步情况下，包括等待时间在内的基础上得到的，所以实际情况可能还要多，当然我们这里没有算上线程切换的时间，所以实际情况中是有一点差异的，但是应该不会很大，因为我们的线程都是基于线程池的操作。所有结果是20个Worker线程不使用异步的情况下，1s能自理200个请求，而使用异步的情况下可以处理360个请求，立马提升80%呀！采用异步之后，对于同样的请求数量，需要的Worker线程数据会大大减少50%左右，一个线程至少会在堆上分配1M的内存，如果是1000个线程那就是1G的容量，虽然内存现在便宜，但是省着总结是好的嘛，而且更少的线程是可以减少线程池在维护线程时产生的CPU消耗的。注意：以上数据并非真实测试数据，真实情况一个request的时间也并非100ms，花费在web service上的时间也并非80ms，仅仅是给大家一个思路:)，所以这里面用了async和await之后对响应能力有多大的提升和我们原来堵塞在这些IO和网络上的时间是有很大的关系的。几点建议看到这里，不知道大家有没有得到点什么。首先第一点我们要知道的是async/await不是万能药，不们不能指望光写两个光键字就希望性能的提升。要记住，一个CPU在同一时间段内是只能执行一个线程的。所以这也是为什么async和await建议在IO或者是网络操作的时候使用。我们的MVC站点访问WCF或者Web Service这种场景就非常的适合使用异步来操作。在上面的例子中80ms读取web service的时间，大部份时间都是不需要cpu操作的，这样cpu才可以被其它的线程利用，如果不是一个读取web service的操作，而是一个复杂计算的操作，那你就等着cpu爆表吧。第二点是，除了程序中利用异步，我们上面讲到的关于IIS的配置是很重要的，如果使用了异步，请记得把maxWorkerThreads和maxConcurrentRequestPerCPU的值调高试试。
早期对Web service的异步编程模式APM讲完我们高大上的async/await之后，我们来看看这个技术很老，但是概念确依旧延续至今的Web Service。 我们这里所说的针对web service的异步编程模式不是指在服务器端的web service本身，而是指调用web service的客户端。大家知道对于web service，我们通过添加web service引用或者.net提供的生成工具就可以生成相应的代理类，可以让我们像调用本地代码一样访问web service，而所生成的代码类中对针对每一个web service方法生成3个对应的方法，比如说我们的方法名叫DownloadContent，除了这个方法之外还有BeginDownloadContent和EndDownloadContent方法，而这两个就是我们今天要说的早期的异步编程模式APM(Asynchronous Programming Model)。下面就来看看我们web service中的代码，注意我们现在的项目都是在.NET Framework3.5下实现的。PageContent.asmx的代码public&class&PageContent&:&System.Web.Services.WebService &{ &&&&&[WebMethod] &&&&&public&string&DownloadContent(string&url) &&&&&{ &&&&&&&&&var&client&=&new&System.Net.WebClient(); &&&&&&&&&return&client.DownloadString(url); &&&&&} &}&注意我们web service中的DownloadContent方法调用的是WebClient的同步方法，WebClient也有异步方法即：DownloadStringAsync。但是大家要明白，不管服务器是同步还是异步，对于客户端来说调用了你这个web service都是一样的，就是得等你返回结果。当然，我们也可以像MVC里面的代码一样，把我们的服务器端也写成异步的。那得到好处的是那个托管web service的服务器，它的处理能力得到提高，就像ASP.NET一样。如果我们用JavaScript去调用这个Web Service，那么Ajax(Asynchronous Javascript + XML)就是我们客户端用到的异步编程技术。如果是其它的客户端呢？比如说一个CS的桌面程序？我们需要异步编程么？当WinForm遇上Web ServiceWinForm不像托管在IIS的ASP.NET网站，会有一个线程池管理着多个线程来处理用户的请求，换个说法ASP.NET网站生来就是基于多线程的。但是，在WinForm中，如果我们不刻意使用多线程，那至始至终，都只有一个线程，称之为UI线程。也许在一些小型的系统中WinForm很少涉及到多线程，因为WinForm本身的优势就在它是独立运行在客户端的，在性能上和可操作性上都会有很大的优势。所以很多中小型的WinForm系统都是直接就访问数据库了，并且基本上也只有数据的传输，什么图片资源那是很少的，所以等待的时间是很短的，基本不用费什么脑力去考虑什么3秒之内必须将页面显示到用户面前这种问题。既然WinForm在性能上有这么大的优势，那它还需要异步吗？我们上面说的是中小型的WinForm，如果是大型的系统呢？如果WinForm只是其它的很小一部分，就像我们文章开始说的还有很多其它成千上万个手机客户端，Web客户端，平板客户端呢？如果客户端很多导致数据库撑不住怎么办？ 想在中间加一层缓存怎么办？拿一个b2b的网站功能举例，用户可以通过网站下单，手机也可以下单，还可以通过电脑的桌面客户端下单。在下完单之后要完成交易，库存扣减，发送订单确认通知等等功能，而不管你的订单是通过哪个端完成的，这些功能我们都要去做，对吗？那我们就不能单独放在WinForm里面了，不然这些代码在其它的端里面又得全部全新再一一实现，同样的代码放在不同的地方那可是相当危险的，所以就有了我们后来的SOA架构，把这些功能都抽成服务，每种类型的端都是调用服务就可以了。一是可以统一维护这些功能，二是可以很方便的做扩展，去更好的适应功能和架构上的扩展。比如说像下面这样的一个系统。在上图中，Web端虽然也是属于我们平常说的服务端（甚至是由多台服务器组成的web群集），但是对我们整个系统来说，它也只是一个端而已。对于一个端来说，它本身只处理和用户交互的问题，其余所有的功能，业务都会交给后来台处理。在我们上面的架构中，应用层都不会直接参加真正业务逻辑相关的处理，而是放到我们更下层数据层去做处理。那么应用层主要协助做一些与用户交互的一些功能，如果手机短信发送，邮件发送等等，并且可以根据优先级选择是放入队列中稍候处理还是直接调用功能服务立即处理。在这样的一个系统中，我们的Web服务器也好，Winform端也好都将只是整个系统中的一个终端，它们主要的任何是用户和后面服务之间的一个桥梁。涉及到Service的调用之后，为了给用户良好的用户体验，在WinForm端，我们自然就要考虑异步的问题。&WinForm异步调用Web Service有了像VS这样强大的工具为我们生成代理类，我们在写调用Web service的代码时就可以像调用本地类库一样调用Web Service了，我们只需要添加一个Web Reference就可以了。// Form1.cs的代码private&void&button1_Click(object&sender,&EventArgs&e) &{ &&&&&var&pageContentService&=&new&localhost.PageContent(); &&&&&pageContentService.BeginDownloadContent( &&&&&&&&&&&, &&&&&&&&&new&AsyncCallback(DownloadContentCallback), &&&&&&&&&pageContentService); &} && &private&void&DownloadContentCallback(IAsyncResult&result) &{ &&&&&var&pageContentService&=&(localhost.PageContent)result.AsyncS &&&&&var&msg&=&pageContentService.EndDownloadContent(result); &&&&&MessageBox.Show(msg); &}&代码非常的简单，在执行完pageContentService.BeginDownloadContent之后，我们的主线程就返回了。在调用Web service这段时间内我们的UI不会被阻塞，也不会出现&无法响应这种情况&，我们依然可以拖动窗体甚至做其它的事情。这就是APM的魔力，但是我们的callback究竟是在哪个线程中执行的呢？是线程池中的线程么？咋们接着往下看。
APM异步编程模式详解线程问题接下来我们就是更进一步的了解APM这种模式是如何工作的，但是首先我们要回答上面留下来的问题，这种异步的编程方式有没有为我们开启新的线程？让代码说话：private&void&button1_Click(object&sender,&EventArgs&e) &{ &&&&&Trace.TraceInformation(&Is&current&thread&from&thread&pool?&{0}&,&Thread.CurrentThread.IsThreadPoolThread&?&&Yes&&:&&No&); &&&&&Trace.TraceInformation(&Start&calling&web&service&on&thread:&{0}&,&Thread.CurrentThread.ManagedThreadId); &&&&&var&pageContentService&=&new&localhost.PageContent(); &&&&&pageContentService.BeginDownloadContent( &&&&&&&&&&&, &&&&&&&&&new&AsyncCallback(DownloadContentCallback), &&&&&&&&&pageContentService); &} && &private&void&DownloadContentCallback(IAsyncResult&result) &{ &&&&&var&pageContentService&=&(localhost.PageContent)result.AsyncS &&&&&var&msg&=&pageContentService.EndDownloadContent(result); && &&&&&Trace.TraceInformation(&Is&current&thread&from&thread&pool?&{0}&&,&Thread.CurrentThread.IsThreadPoolThread&?&&Yes&&:&&No&); &&&&&Trace.TraceInformation(&End&calling&web&service&on&thread:&{0},&the&result&of&the&web&service&is:&{1}&, &&&&&&&&&Thread.CurrentThread.ManagedThreadId, &&&&&&&&&msg); &}&我们在按钮点击的方法和callback方法中分别输出当前线程的ID，以及他们是否属于线程池的线程，得到的结果如下：Desktop4.0.vshost.exe&Information:&0&:&Is&current&thread&a&background&thread?&NO &Desktop4.0.vshost.exe&Information:&0&:&Is&current&thread&from&thread&pool?&NO &Desktop4.0.vshost.exe&Information:&0&:&Start&calling&web&service&on&thread:&9 &Desktop4.0.vshost.exe&Information:&0&:&Is&current&thread&a&background&thread?&YES &Desktop4.0.vshost.exe&Information:&0&:&Is&current&thread&from&thread&pool?&YES &Desktop4.0.vshost.exe&Information:&0&:&End&calling&web&service&on&thread:&14,&the&result&of&the&web&service&is:&&!DOCTYPE&html...&按钮点击的方法是由UI直接控制，很明显它不是一个线程池线程，也不是后台线程。而我们的callback却是在一个来自于线程池的后台线程执行的，答案揭晓了，可是这会给我们带来一个问题，我们上面讲了只有UI线程也可以去更新我们的UI控件，也就是说在callback中我们是不能更新UI控件的，那我们如何让更新UI让用户知道反馈呢？答案在后面接晓 :)，让我们先专注于把APM弄清楚。从Delegate开始其实，APM在.NET3.5以前都被广泛使用，在WinForm窗体控制中，在一个IO操作的类库中等等！大家可以很容易的找到搭配了Begin和End的方法，更重要的是只要是有代理的地方，我们都可以使用APM这种模式。我们来看一个很简单的例子：delegate&void&EatAsync(string&food); &private&void&button2_Click(object&sender,&EventArgs&e) &{ &&&&&var&myAsync&=&new&EatAsync(eat); &&&&&Trace.TraceInformation(&Activate&eating&on&thread:&{0}&,&Thread.CurrentThread.ManagedThreadId); &&&&&myAsync.BeginInvoke(&icecream&,&new&AsyncCallback(clean),&myAsync); &} && &private&void&eat(string&food) &{ &&&&&Trace.TraceInformation(&I&am&eating....&on&thread:&{0}&,&Thread.CurrentThread.ManagedThreadId); &} && &private&void&clean(IAsyncResult&asyncResult) &{ &&&&&Trace.TraceInformation(&I&am&done&eating....&on&thread:&{0}&,&Thread.CurrentThread.ManagedThreadId); &}&上面的代码中，我们通过把eat封装成一个委托，然后再调用该委托的BeginInvoke方法实现了异步的执行。也就是实际的eat方法不是在主线程中执行的，我们可以看输出的结果：Desktop4.0.vshost.exe&Information:&0&:&Activate&eating&on&thread:&10 &Desktop4.0.vshost.exe&Information:&0&:&I&am&eating....&on&thread:&6 &Desktop4.0.vshost.exe&Information:&0&:&I&am&done&eating....&on&thread:&6&clean是我们传进去的callback，该方法会在我们的eat方法执行完之后被调用，所以它会和我们eat方法在同一个线程中被调用。大家如果熟悉代理的话就会知道，代码实际上会被编译成一个类，而BeginInvoke和EndInvoke方法正是编译器为我们自动加进去的方法，我们不用额外做任何事情，这在早期没有TPL和async/await之前（APM从.NET1.0时代就有了），的确是一个不错的选择。再次认识APM了解了Delegate实现的BeginInvoke和EndInvoke之后，我们再来分析一下APM用到的那些对象。 拿我们Web service的代理类来举例，它为我们生成了以下3个方法：
string DownloadContent(string url)： 同步方法
IAsyncResult BeginDownloadContent(string url, AsyncCallback callback, object asyncState)： 异步开始方法
EndDownloadContent(IAsyncResult asyncResult)：异步结束方法在我们调用EndDownloadContent方法的时候，如果我们的web service调用还没有返回，那这个时候就会用阻塞的方式去拿结果。但是在我们传到BeginDownloadContent中的callback被调用的时候，那操作一定是已经完成了，也就是说IAsyncResult.IsCompleted = true。而在APM异步编程模式中Begin方法总是返回IAsyncResult这个接口的实现。IAsyncReuslt仅仅包含以下4个属性：WaitHanlde通常作为同步对象的基类，并且可以利用它来阻塞线程，更多信息可以参考MSDN&。 借助于IAsyncResult的帮助，我们就可以通过以下几种方式去获取当同所执行操作的结果。
完成通知完成通知就是们上面用到的那种，调完Begin方法之后，主线程就算完成任务了。我们也不用监控该操作的执行情况，当该操作执行完之后，我们在Begin方法中传进去的callback就会被调用了，我们可以在那个方法中调用End方法去获取结果。下面我们再简单说一下前面两种方式。//轮询获取结果代码var&pageContentService&=&new&localhost.PageContent(); &IAsyncResult&asyncResult&=&pageContentService.BeginDownloadContent( &&&&&&&, &&&&&null, &&&&&pageContentService); && &while&(!asyncResult.IsCompleted) &{ &&&&&Thread.Sleep(100); &} &var&content&=&pageContentService.EndDownloadContent(asyncResult);&// 强制等待结果代码var&pageContentService&=&new&localhost.PageContent(); &IAsyncResult&asyncResult&=&pageContentService.BeginDownloadContent( &&&&&&&, &&&&&null, &&&&&pageContentService); && &&if&(asyncResult.AsyncWaitHandle.WaitOne(2000)) &{ &&&&&var&content&=&pageContentService.EndDownloadContent(asyncResult); &} &else&{& &&&&&&}&
EAP(Event-Based Asynchronous Pattern)EAP是在.NET2.0推出的另一种过渡的异步编程模型，也是在.NET3.5以后Microsoft支持的一种做法，为什么呢？ 如果大家建一个.NET4.0或者更高版本的WinForm项目，再去添加Web Reference就会发现生成的代理类中已经没有Begin和End方法了，记住在3.5的时候是两者共存的，你可以选择任意一种来使用。但是到了.NET4.0以后，EAP成为了你唯一的选择。（我没有尝试过手动生成代理类，有兴趣的同学可以尝试一下）让我们来看一下在.NET4下，我们是如何异步调用Web Service的。private&void&button1_Click(object&sender,&EventArgs&e) &{ &&&&&var&pageContent&=&new&localhost.PageContent(); &&&&&pageContent.DownloadContentAsync(&&); &&&&&pageContent.DownloadContentCompleted&+=&pageContent_DownloadContentC &} && &private&void&pageContent_DownloadContentCompleted(object&sender,&localhost.DownloadContentCompletedEventArgs&e) &{ &&&&&if&(e.Error&==&null) &&&&&{ &&&&&&&&&textBox1.Text&=&e.R &&&&&} &&&&&else&&&&&{& &&&&&&&&&&&&&&} &}&线程问题不知道大家还是否记得，在APM模式中，callback是执行在另一个线程中，不能随易的去更新UI。但是如果你仔细看一下上面的代码，我们的DownloadContentCompleted事件绑定的方法中直接就更新了UI，把返回的内容写到了一个文本框里面。通过同样的方法可以发现，在EAP这种异步编程模式下，事件绑定的方法也是在调用的那个线程中执行的。也就是说解决了异步编程的时候UI交互的问题，而且是在同一个线程中执行。 看看下面的代码：private&void&button1_Click(object&sender,&EventArgs&e) &{ &&&&&Trace.TraceInformation(&Call&DownloadContentAsync&on&thread:&{0}&,&Thread.CurrentThread.ManagedThreadId); &&&&&Trace.TraceInformation(&Is&current&from&thread&pool?&:&{0}&,&Thread.CurrentThread.IsThreadPoolThread&?&&YES&&:&&NO&); && &&&&&var&pageContent&=&new&localhost.PageContent(); &&&&&pageContent.DownloadContentAsync(&&); &&&&&pageContent.DownloadContentCompleted&+=&pageContent_DownloadContentC &} && &private&void&pageContent_DownloadContentCompleted(object&sender,&localhost.DownloadContentCompletedEventArgs&e) &{ &&&&&Trace.TraceInformation(&Completed&DownloadContentAsync&on&thread:&{0}&,&Thread.CurrentThread.ManagedThreadId); &&&&&Trace.TraceInformation(&Is&current&from&thread&pool?&:&{0}&,&Thread.CurrentThread.IsThreadPoolThread&?&&YES&&:&&NO&); &}&Desktop4.vshost.exe&Information:&0&:&Call&DownloadContentAsync&on&thread:&10 &Desktop4.vshost.exe&Information:&0&:&Is&current&from&thread&pool?&:&NO &Desktop4.vshost.exe&Information:&0&:&Completed&DownloadContentAsync&on&thread:&10 &Desktop4.vshost.exe&Information:&0&:&Is&current&from&thread&pool?&:&NO&
async/await 给WinFrom带来了什么如果说async给ASP.NET带来的是处理能力的提高，那么在WinForm中给程序员带来的好处则是最大的。我们再也不用因为要实现异步写回调或者绑定事件了，省事了，可读性也提高了。不信你看下面我们将调用我们那个web service的代码在.NET4.5下实现一下：private&async&void&button2_Click(object&sender,&EventArgs&e) &{ &&&&&var&pageContent&=&new&localhost.PageContentSoapClient(); &&&&&var&content&=&await&pageContent.DownloadContentAsync(&&); && &&&&&textBox1.Text&=&content.Body.DownloadContentR &}&简单的三行代码，像写同步代码一样写异步代码，我想也许这就是async/await的魔力吧。在await之后，UI线程就可以回去响应UI了，在上面的代码中我们是没有新线程产生的，和EAP一样拿到结果直接就可以对UI操作了。async/await似乎真的很好，但是如果我们await后面的代码执行在另外一个线程中会发生什么事情呢？private&async&void&button1_Click(object&sender,&EventArgs&e) &{ &&&&&label1.Text&=&&Calculating&Sqrt&of&5000000&; &&&&&button1.Enabled&=&false; &&&&&progressBar1.Visible&=&true; && &&&&&double&sqrt&=&await&Task&double&.Run(()&=& &&&&&{ &&&&&&&&&double&result&=&0; &&&&&&&&&for&(int&i&=&0;&i&&&;&i++) &&&&&&&&&{ &&&&&&&&&&&&&result&+=&Math.Sqrt(i); && &&&&&&&&&&&&&progressBar1.Maximum&=&; &&&&&&&&&&&&&progressBar1.Value&=&i; &&&&&&&&&} &&&&&&&&&return& &&&&&}); && &&&&&progressBar1.Visible&=&false; &&&&&button1.Enabled&=&true; &&&&&label1.Text&=&&The&sqrt&of&&is&&&+& &}&我们在界面中放了一个ProgressBar，同时开一个线程去把从1到5000000的平方全部加起来，看起来是一个非常耗时的操作，于是我们用Task.Run开了一个新的线程去执行。（注：如果是纯运算的操作，多线程操作对性能没有多大帮助，我们这里主要是想给UI一个进度显示当前进行到哪一步了。）看起来没有什么问题，我们按F5运行吧！Bomb~当执行到这里的时候，程序就崩溃了，告诉我们&无效操作，只能从创建porgressBar的线程访问它。& &这也是我们一开始提到的，在WinForm程序中，只有UI主线程才能对UI进行操作，其它的线程是没有权限的。接下来我们就来看看，如果在WinForm中实现非UI线程对UI控制的更新操作。&
不同线程之间通讯的问题万能的InvokeWinForm中绝大多数的控件包括窗体在内都实现了Invoke方法，可以传入一个Delegate，这个Delegate将会被拥有那个控制的线程所调用，从而避免了跨线程访问的问题。Trace.TraceInformation(&UI&Thread&:&{0}&,&Thread.CurrentThread.ManagedThreadId); &double&sqrt&=&await&Task&double&.Run(()&=& &{ &&&&&Trace.TraceInformation(&Run&calculation&on&thread:&{0}&,&Thread.CurrentThread.ManagedThreadId); &&&&&double&result&=&0; &&&&&for&(int&i&=&0;&i&&&;&i++) &&&&&{ &&&&&&&&&result&+=&Math.Sqrt(i); &&&&&&&&&progressBar1.Invoke(new&Action(()&=&&{ &&&&&&&&&&&&&Trace.TraceInformation(&Update&UI&on&thread:&{0}&,&Thread.CurrentThread.ManagedThreadId); &&&&&&&&&&&&&progressBar1.Maximum&=&; &&&&&&&&&&&&&progressBar1.Value&=&i; &&&&&&&&&})); &&&&&} &&&&&return& &});&Desktop.vshost.exe&Information:&0&:&UI&Thread&:&9 &Desktop.vshost.exe&Information:&0&:&Run&calculation&on&thread:&10 &Desktop.vshost.exe&Information:&0&:&Update&UI&on&thread:&9&Invoke方法比较简单，我们就不做过多的研究了，但是我们要考虑到一点，Invoke是WinForm实现的UI同交互技术，WPF用的却是Dispatcher，如果是在ASP.NET下跨线程之间的同步又怎么办呢。为了兼容各种技术平台下，跨线程同步的问题，Microsoft在.NET2.0的时候就引入了我们下面的这个对象。SynchronizationContext上下文同步对象为什么需要SynchronizationContext就像我们在WinForm中遇到的问题一样，有时候我们需要在一个线程中传递一些数据或者做一些操作到另一个线程。但是在绝大多数情况下这是不允许的，出于安全因素的考虑，每一个线程都有它独立的内存空间和上下文。因此在.NET2.0，微软推出了SynchronizationContext。它主要的功能之一是为我们提供了一种将一些工作任务（Delegate)以队列的方式存储在一个上下文对象中，然后把这些上下文对象关联到具体的线程上，当然有时候多个线程也可以关联到同一个SynchronizationContext对象。获取当前线程的同步上下文对象可以使用SynchronizationContext.Current。同时它还为我们提供以下两个方法Post和Send，分别是以异步和同步的方法将我们上面说的工作任务放到我们SynchronizationContext的队列中。SynchronizationContext示例还是拿我们上面Invoke中用到的例子举例，只是这次我们不直接调用控件的Invoke方法去更新它，而是写了一个Report的方法专门去更新UI。double&sqrt&=&await&Task&double&.Run(()&=& &{ &&&&&Trace.TraceInformation(&Current&thread&id&is:{0}&,&Thread.CurrentThread.ManagedThreadId); && &&&&&double&result&=&0; &&&&&for&(int&i&=&0;&i&&&;&i++) &&&&&{ &&&&&&&&&result&+=&Math.Sqrt(i); &&&&&&&&&Report(new&Tuple&int,&int&(,&i)); &&&&&} &&&&&return& &});&每一次操作完之后我们调用一下Report方法，把我们总共要算的数字，以前当前正在计算的数字传给它就可以了。接下来就看我们的Report方法了。private&SynchronizationContext&m_SynchronizationC &private&DateTime&m_PreviousTime&=&DateTime.N && &public&Form1() &{ &&&&&InitializeComponent(); &&&&&&&&&&m_SynchronizationContext&=&SynchronizationContext.C &} && &public&void&Report(Tuple&int,&int&&value) &{ &&&&&DateTime&now&=&DateTime.N &&&&&if&((now&-&m_PreviousTime).Milliseconds&&&100) &&&&&{ &&&&&&&&&m_SynchronizationContext.Post((obj)&=& &&&&&&&&&{ &&&&&&&&&&&&&Tuple&int,&int&&minMax&=&(Tuple&int,&int&) &&&&&&&&&&&&&progressBar1.Maximum&=&minMax.Item1; &&&&&&&&&&&&&progressBar1.Value&=&minMax.Item2; &&&&&&&&&},&value); && &&&&&&&&&m_PreviousTime&=& &&&&&} &}&整个操作看起来要比Inovke复杂一点，与Invoke不同的是SynchronizationContext不需要对Control的引用，而Invoke必须先得有那个控件才能调用它的Invoke方法去更新它。
小结这篇博客内容有点长，不知道有多少人可以看到这里:)。最开始我只是想写写WinFrom下异步调用Web Service的一些东西，在我开始这篇文件的题目是&异步编程在WinForm下的实践&，但是写着写着发现越来越多的迷团没有解开，其实都是一些老的技术以前没有接触和掌握好，所以所幸就一次性把他们都重新学习了一遍，与大家分享。我们再来回顾一下文章所涉及到的一些重要的概念：
async/await 在ASP.NET做的最大贡献（早期ASP.NET的异步开发模式同样也有这样的贡献），是在访问数据库的时候、访问远程IO的时候及时释放了当前的处理性程，可以让这些线程回到线程池中，从而实现可以去处理其它请求的功能。
异步的ASP.NET开发能够在处理能力上带来多大的提高，取决于我们的程序有多少时间是被阻塞的，也就是那些访问数据库和远程Service的时间。
除了将代码改成异步，我们还需要在IIS上做一些相对的配置来实现最优化。
不管是ASP.NET、WinForm还是Mobile、还是平板，在大型系统中都只是一个与用户交互的端而已，所以不管你现在是做所谓的前端（JavaScript + CSS等)，还是所谓的后端(ASP.NET MVC、WCF、Web API 等 )，又或者是比较时髦的移动端（IOS也好，Andrioid也罢，哪怕是不争气的WP），都只是整个大型系统中的零星一角而已。当然我并不是贬低这些端的价值，正是因为我们专注于不同，努力提高每一个端的用户体验，才能让这些大型系统有露脸的机会。我想说的是，在你对现在技术取得一定的成就之后，不要停止学习，因为整个软件架构体系中还有很多很多美妙的东西值得我们去发现。
APM和EAP是在async/await之前的两种不同的异步编程模式。
APM如果不阻塞主线程，那么完成通知（回调）就会执行在另外一个线程中，从而给我们更新UI带来一定的问题。
EAP的通知事件是在主线程中执行的，不会存在UI交互的问题。
最后，我们还学习了在Winform下不同线程之间交互的问题，以及SynchronizationContext。
APM是.NET下最早的异步编程方法，从.NET1.0以来就有了。在.NET2.0的时候，微软意识到了APM的回调函数中与UI交互的问题，于是带来了新的EAP。APM与EAP一直共存到.NET3.5，在.NET4.0的时候微软带来了TPL，也就是我们所熟知的Task编程，而.NET4.5就是我们大家知道的async/await了，可以看到.NET一直在不停的进步，加上最近不断的和开源社区的合作，跨平台等特性的引入，我们有理由相信.NET会越走越好。最后，这篇文章从找资料学习到写出来，差不多花了我两个周未的时间，希望能够给需要的人或者感兴趣想要不断学习的人一点帮助（不管是往前学习，还是往后学习）。&引用 & 扩展阅读/b/tmarq/archive//performing-asynchronous-work-or-tasks-in-asp-net-applications.aspx//improve-scalability-in-aspnet-mvc-using-asynchronous-requests/b/tmarq/archive//asp-net-thread-usage-on-iis-7-0-and-6-0.aspx&/b/tmarq/archive//performing-asynchronous-work-or-tasks-in-asp-net-applications.aspx//thread-throttling-in-iis-hosted-wcf-sync-vs-async/Pro Asynchronous Programs with .NET by Richard Blewett and Andrew Clymer本文来自：/jesse2013/p/Asynchronous-Programming-In-DotNet.html#aspnet-async
聚生网管官网,控制其他主机网速,管理公司上网,局域网禁止网络游戏,网络带宽控制,局域网流量监控软件
大势至公司网络管理产品：
1、，是国内最早、最专业的局域网监控软件、上网行为控制系统，可以有效管理公司局域网电脑上网行为，有效屏蔽迅雷下载、禁止迅雷上传，禁止pps上传、禁止看qq直播、禁止局域网玩游戏、禁止登录QQ游戏大厅、禁止员工炒股、限制上班看电影、进行局域网带宽限制、控制打开网页、禁止局域网网购、监控邮件内容、监控邮件附件、记录论坛发帖留言、防ARP攻击、查找局域网手机、禁止手机接入公司局域网、禁止私自安装无线路由器上网、防止无线局域网蹭网等;
2、，专业的上网行为管理服务器、比上网行为管理路由器、上网管理路由器更强大，可以有效禁止电脑游戏、屏蔽网页游戏、限制局域网看视频、禁止别人看视频、限制P2P软件使用、禁止快车下载、局域网控制迅雷下载、限制股票软件、禁止上班炒股行为、进行局域网流量监控、限制带宽软件，禁止员工网络购物、屏蔽购物网站、屏蔽网页视频网站，并且独创了&创新直连&监控模式，国内最快捷、最简单、最安全控制多网段电脑上网行为，监控效率和综合性能最强的硬件网络管理系统、上网行为管理系统。
3、，一款强大的USB端口控制系统，有效禁用USB端口使用、屏蔽U口、禁止电脑使用U盘、屏蔽优盘使用、禁用优盘，禁止移动硬盘使用、禁止手机存储卡使用，可以有效地屏蔽USB存储设备而不影响USB鼠标键盘和非USB设备的使用；同时，还可以禁止修改注册表、禁止修改组策略、禁止修改msconfig启动项、禁止修改计算机管理、禁止F8键进入安全模式、禁止U盘启动电脑、禁止光驱启动电脑；此外，还可以只允许电脑访问特定网站，只让打开特定程序、只让运行特定软件或者禁止运行某些程序、禁止访问某些网站等；
4、，是一款强大的共享文件服务器监控软件、服务器文件管理系统、服务器文件访问控制软件，最有效监控服务器共享文件的访问，详细记录修改服务器共享文件、删除服务器共享文件、复制服务器共享文件、剪切服务器共享文件或者打印服务器共享文件的行为，以及重命名共享文件等；同时，记录访问共享文件者的IP地址、MAC地址、主机名和域账号等信息，从而可以为网管员提供详细的服务器文件访问日志，便于加强服务器共享文件管理，保护单位无形资产和商业机密等；
5、，是一款专业的公司局域网接入管理软件、内网接入控制系统，可以有效防止非公司电脑访问公司局域网、禁止外部电脑访问公司局域网、限制外来电脑接入公司局域网、禁止手机接入公司局域网、禁止手机无线上网、限制平板电脑无线上网，检测局域网处于混杂模式的网卡，防止局域网抓包、防止局域网嗅探；同时，还可以查找局域网无线路由器，禁止无线路由器接入公司局域网，禁止无线路由器上网，禁止局域网启用代理，限制员工代理上网，禁止电脑安装代理软件为其他电脑提供代理上网服务等；
6、，是一款专门由于管理共享文件访问、进行共享文件访问权限设置的软件，通过在开启共享文件的电脑或服务器安装以后就可以为本地账号分配共享文件的不同访问权限，这样局域网用户访问共享文件的时候就只能&读取&共享文件而禁止拷贝共享文件的内容、禁止将共享文件另存为本地磁盘、禁止打印共享文件；同时，对共享文件加密后用户访问共享文件的时候将被限定在一个特定的共享文件列表框内访问操作，可以禁止拖拽共享文件、禁止拷贝共享文件、禁止剪切共享文件到访问者自己的电脑，从而也可以防止U盘复制共享文件、防止通过网盘上传共享文件、防止通过FTP上传共享文件以及防止通过QQ将共享文件发送到外面去，从而全面保护了共享文件的安全。
7、&，是一款专门监控FTP服务器文件访问操作日志的软件，可以详细记录局域网用户对FTP服务器文件的上传、下载、修改、删除、重命名等操作日志，可以记录访问者的FTP账户、IP地址、MAC地址和主机名等信息，并可以将FTP服务器文件操作日志导出为Excel格式，从而便于网管员实时审计局域网用户对FTP服务器文件上传和FTP服务器下载文件的情况，便于更好地保护FTP服务器的文件安全，保护单位无形资产和商业机密。
公司简介：大势至公司是国内最早的企业网管软件提供商，可以为企事业单位提供整体的企业网络管理方案和企业网络管理平台，通过全系列的公司监控员工电脑软件教你如何控制员工上网、如何控制局域网内电脑上网以及如何保护电脑文件安全等。公司核心产品“聚生网管系统”是一款专门的公司网管必备软件、查看网络流量软件、网络流量监控软件和办公室电脑监控软件；“网络特警”则是一款专门的网络流量监控设备、上网行为管理服务器、网络行为管理设备，可以实现更为强大的局域网网络行为管理；大势至USB接口禁用软件则是一款专门的数据防泄密产品、屏蔽U盘软件、电脑USB端口禁用软件，可以严防通过一切途径泄露电脑文件，保护单位无形资产和商业机密安全；大势至共享文件夹管理软件则是一款专门的共享文件权限设置软件和共享文件设置密码软件，全面保护共享文件安全；大势至共享文件审计系统则是一款专门的服务器共享文件夹设置软件、服务器共享文件访问日志记录软件，可以详细记录局域网用户访问共享文件的行为，更好地管理共享文件的安全；大势至局域网网络准入控制系统则是一款专门防止未经授权的电脑接入公司局域网的行为，防止外来电脑访问局域网共享文件、防止蹭网以及绑定IP和MAC地址，保护网络安全；大势至FTP服务器日志记录软件则是一款专门记录局域网用户访问FTP服务器日志的软件，可以有效保护FTP服务器文件安全。
售前咨询：-04
电话：010-
电话：010-
电话：010-
电话：010-
电话：010-