原文地址:
http://flier-lu.blogcn.com/diary,109210941.shtml
与 ASP.NET 1.0 相比，ASP.NET 2.0 的各方面改进可以说是非常巨大的。但就其实现层面来说，最大的增强莫过于提供了对异步页面的支持。通过此机制，编写良好的页面可以将数据库、WebService 调用等慢速操作，对网站吞吐能力的影响降到最低，并极大的改善网站的平均页面响应速度。本文将从使用和实现两个层面，简单的剖析这一强大机制的原理，以便读者能够更好的应用这一机制。
对一个网页请求的生命周期来说，首先是 Web 服务器收到客户端 HTTP 请求，将请求转交给 ASP.NET 引擎；引擎将以流水线方式调用合适的 Web 应用程序和最终的页面进行处理；页面会根据请求内容，执行某些后台操作，如访问数据库、调用远程 WebService 等等；最终将结果以某种可视化形式，展示到最终用户的浏览器中。
而为了提高响应速度和吞吐量，现代的 Web 服务器往往会将 Web 应用程序和页面，放在一个缓冲池中备用，避免每次处理请求时重建环境。而请求到来时，Web 服务器会从一个系统线程池中获取临时线程，调用从 Web 应用程序和页面缓冲池中获取的处理实例，完成对请求的处理，并最终返回处理的结果。
咋一看这种机制非常完美，能够最大限度的重用系统资源，但实际上其中存在着很大的优化余地。
我们可以将一个页面请求的处理过程进一步细化为下面步骤：
1.Web 服务器接受请求并由引擎转发请求
2.页面处理请求，访问数据库、调用远程 WebService 等
3.页面将处理结果，以某种形式展现，如 HTML 表格等
4.Web 服务器将结果返回给最终客户的浏览器
其中第一步涉及到核心态网络驱动，需要频繁切换回用户态，以将请求转交给处理引擎。这里涉及到大量的核心态和用户态切换。为减少这个负担，IIS 6 开始提供了 http.sys 在核心态直接对大多数请求进行处理。这是 MS 在中间件一级就已经替我们做好的优化，我们无需也无法关心。
而另外一个潜在的优化点就是异步页面的目标：增强页面处理请求的并发性。
Web 服务器在从线程池获取临时线程后，在线程中调用页面相关代码处理请求。而这里的请求处理过程往往涉及到较为缓慢的操作，例如访问数据库、调用远程 WebService 等。如果数据库是在本机的话还好，系统 CPU 时间只是从处理线程移交到后台数据库线程；而一旦处理运算逻辑在远程，例如访问外部独立数据库，或调用 WebService 完成某种操作，此时此线程就只能无谓的等待操作结束。而作为 Web 服务器处理客户端请求的线程池，其最大容纳线程的数量肯定是有限的。（虽然大多数情况下这个上限值可以修改，例如 ASP.NET 中可以通过修改 machine.config 的 processModel 标签调整最大数量，缺省25）。一旦超过此数量的请求正在并行执行，或者说正在等待后台慢速的操作，此时新来的请求就会因为处理请求线程池中无可用线程，出现虽然 CPU 负荷非常低，但仍出现 “503 服务器不可用” 类似的错误，从而事实上造成对应用的 DoS（拒绝服务）攻击。即使此上限设置很大，也会因为大量等待操作，降低其它本可以快速的页面的响应速度。
要处理这种情况，虽然可以通过继续增大请求处理线程池最大容量缓解，但总是治标不治本。更好的方法就是将请求处理和页面处理分离，避免慢速页面处理占用快速请求处理的时间。页面在接受到引擎的处理页面请求后，通过调用异步方法来试图完成实际页面处理，处理结果从单独线程池获取线程进行监控，而发送页面请求的请求处理线程将被直接释放，以便继续处理其它的页面请求。这也就是 ASP.NET 异步页面的基本思路。实际上这个思路在 ASP.NET 1.1 时就已经提出，Fritz Onion 曾于 2003 年在 MSDN 杂志发表过一篇文章详细讨论这个问题，并给出了一个简单的解决方案。
Use Threads and Build Asynchronous Handlers in Your Server-Side Web Code
文中提供的实现，很好的对此问题进行原理上的验证。但从实现角度较为繁琐，需要自行处理 IAsyncResult 接口以及自定义线程池，而且缺少对 HTTP 上下文以及超时等的处理。
好在 ASP.NET 2.0 对此问题提供了内建的支持，Jeff Prosise 在 MSDN 杂志的文章中详细的讨论了其实现思路和使用方法。
Asynchronous Pages in ASP.NET 2.0
从使用角度来说，异步页面的支持非常透明。使用者只需要在页面定义的 Page 标签中指定异步模式，例如：
然后就可以在 Page 的实现代码中，通过 Page 类型的 AddOnPreRenderCompleteAsync 或 PageAsyncTask 方法，提交异步的页面处理代码。ASP.NET 引擎会根据页面的异步模式设定，调用合适的页面处理开始和结束方法。
对大多数简单的异步处理情况，可以直接调用 AddOnPreRenderCompleteAsync 方法，提交页面请求开始和结束时的处理代码，例如上述文章中给出的一个内部处理 HTTP 页面请求的例子：
AsyncPage 页面的 OnLoad 事件中提交异步处理方法；ASP.NET 引擎会在页面加载完成后，调用 BeginAsyncOperation 方法启动异步方法。这里的异步请求是打开一个远程 Web 页面，而大多数诸如数据库、WebService 调用等等，都提供了类似的异步调用版本。页面处理开始方法会返回异步调用请求的 IAsyncResult 封装，通过此接口检测处理的完成情况。而在 BeginAsyncOperation 方法返回之后，处理连接请求的线程将回到线程池，用来处理后续的连接请求。直到实际的异步处理操作完成，例如 Web 页面被取回，引擎才会从独立线程池中获取临时线程，调用 EndAsyncOperation 方法完成后续的操作。
其实际的处理流程如下图所示：
screen.width/2)this.style.width=screen.width/2;" border=0>
而 PageAsyncTask 的方式则是增强版本，除了异步页面处理开始和结束方法自身外，还可以提供在超时情况下的处理方法，以及处理时的状态对象。上述文章中给出的对应例子如下：
为验证这一机制的实现效果，我们可以在各个方法的入口处设置断点。因为 VS2005 的 IDE 屏蔽了底层 CLR 实现信息，我们需要在 Debug\Windows\Immediate Window 窗口中，输入 .load sos 命令加载 CLR 调试支持。具体的 sos 命令可以输入 !help 查询帮助，或参考我以前《用WinDbg探索CLR世界》的系列文章，这里不再罗嗦。
在 AsyncPage 类型的 Page_Load、BeginAsyncOperation 和 EndAsyncOperation 方法中，分别输入 !ClrStack 命令可以获取当前线程的调用堆栈：
可以看到 Page_Load 和 BeginAsyncOperation 方法都是在 ID 为 2816 的线程中被调用，其调用源也都是处理 HTTP 请求的 HttpRuntime.ProcessRequest 方法；而 EndAsyncOperation 则是在另外一个 ID 为 3376 的线程中调用，调用源也是完成网络读操作的 Connection.ReadComplete 方法。
而从实现角度来看，AddOnPreRenderCompleteAsync 方法将异步页面处理的启动和停止方法，放到一个 Page.PageAsyncInfo 对象中。此对象维护了与页面相关的各种上下文信息，以及开始、停止和状态的数组。而 RegisterAsyncTask 方法也是类似，将 PageAsyncTask 实例放到 PageAsyncTaskManager 类型的管理器中。
HttpApplication 在处理页面请求时，通过其 pipeline 的 CallHandlerExecutionStep 步骤，调用页面的 BeginProcessRequest 方法，其伪代码如下：
而 ASP.NET 页面一旦通过 Page 标记定义为异步模式，其编译生成的 Page 子类就会实现 IHttpAsyncHandler 接口。
例如对上述例子，我们可以通过 !ClrStack 命令看到页面被编译为名称为 ASP.asyncpage_aspx 的类型。
进一步使用 !DumpDomain 命令可以找到其页面编译的临时文件，如
使用 IL 反汇编根据打开此文件，可以看到 AsyncPage.aspx 被编译为 asyncpage_aspx 类型，如下所示：
其中 AsyncPage 类型是后台实现代码编译生成的类型，asyncpage_aspx 则是 .aspx 页面编译生成。
而在 Page.AsyncPageBeginProcessRequest 方法中，将首先处理上下文环境初始化，初始化异步执行信息，以及相应回调函数的执行；然后会调用 PageAsyncTaskManager.RegisterHandlersForPagePreRenderCompleteAsync 将异步任务管理器中所有的异步任务，封装后注册到 Page.PageAsyncInfo 对象中维护的异步调用信息中；最后调用 其 CallHandlers 方法完成对异步处理开始方法的调用。完整的伪代码如下：
而在 PageAsyncTaskManager 中被管理的异步任务，会作为一个异步执行信息注册到 PageAsyncInfo 中去。并在其被调用时，实际调用 PageAsyncTaskManager 类型的 ExecuteTasks 方法，实现较为复杂的异步调用逻辑。
以上我们对异步页面的目的、范围、使用方式和实现原理等，有了一个大致的了解。并针对异步任务的管理做了简要的分析，基本上已经能弄清异步页面的静态运行机制如何。下一节我们将从动态执行的角度，对两级异步任务，以及相应的调度和线程使用做进一步探索。
to be continue...
http://flier-lu.blogcn.com/diary,109210941.shtml
与 ASP.NET 1.0 相比，ASP.NET 2.0 的各方面改进可以说是非常巨大的。但就其实现层面来说，最大的增强莫过于提供了对异步页面的支持。通过此机制，编写良好的页面可以将数据库、WebService 调用等慢速操作，对网站吞吐能力的影响降到最低，并极大的改善网站的平均页面响应速度。本文将从使用和实现两个层面，简单的剖析这一强大机制的原理，以便读者能够更好的应用这一机制。
对一个网页请求的生命周期来说，首先是 Web 服务器收到客户端 HTTP 请求，将请求转交给 ASP.NET 引擎；引擎将以流水线方式调用合适的 Web 应用程序和最终的页面进行处理；页面会根据请求内容，执行某些后台操作，如访问数据库、调用远程 WebService 等等；最终将结果以某种可视化形式，展示到最终用户的浏览器中。
而为了提高响应速度和吞吐量，现代的 Web 服务器往往会将 Web 应用程序和页面，放在一个缓冲池中备用，避免每次处理请求时重建环境。而请求到来时，Web 服务器会从一个系统线程池中获取临时线程，调用从 Web 应用程序和页面缓冲池中获取的处理实例，完成对请求的处理，并最终返回处理的结果。
咋一看这种机制非常完美，能够最大限度的重用系统资源，但实际上其中存在着很大的优化余地。
我们可以将一个页面请求的处理过程进一步细化为下面步骤：
1.Web 服务器接受请求并由引擎转发请求
2.页面处理请求，访问数据库、调用远程 WebService 等
3.页面将处理结果，以某种形式展现，如 HTML 表格等
4.Web 服务器将结果返回给最终客户的浏览器
其中第一步涉及到核心态网络驱动，需要频繁切换回用户态，以将请求转交给处理引擎。这里涉及到大量的核心态和用户态切换。为减少这个负担，IIS 6 开始提供了 http.sys 在核心态直接对大多数请求进行处理。这是 MS 在中间件一级就已经替我们做好的优化，我们无需也无法关心。
而另外一个潜在的优化点就是异步页面的目标：增强页面处理请求的并发性。
Web 服务器在从线程池获取临时线程后，在线程中调用页面相关代码处理请求。而这里的请求处理过程往往涉及到较为缓慢的操作，例如访问数据库、调用远程 WebService 等。如果数据库是在本机的话还好，系统 CPU 时间只是从处理线程移交到后台数据库线程；而一旦处理运算逻辑在远程，例如访问外部独立数据库，或调用 WebService 完成某种操作，此时此线程就只能无谓的等待操作结束。而作为 Web 服务器处理客户端请求的线程池，其最大容纳线程的数量肯定是有限的。（虽然大多数情况下这个上限值可以修改，例如 ASP.NET 中可以通过修改 machine.config 的 processModel 标签调整最大数量，缺省25）。一旦超过此数量的请求正在并行执行，或者说正在等待后台慢速的操作，此时新来的请求就会因为处理请求线程池中无可用线程，出现虽然 CPU 负荷非常低，但仍出现 “503 服务器不可用” 类似的错误，从而事实上造成对应用的 DoS（拒绝服务）攻击。即使此上限设置很大，也会因为大量等待操作，降低其它本可以快速的页面的响应速度。
要处理这种情况，虽然可以通过继续增大请求处理线程池最大容量缓解，但总是治标不治本。更好的方法就是将请求处理和页面处理分离，避免慢速页面处理占用快速请求处理的时间。页面在接受到引擎的处理页面请求后，通过调用异步方法来试图完成实际页面处理，处理结果从单独线程池获取线程进行监控，而发送页面请求的请求处理线程将被直接释放，以便继续处理其它的页面请求。这也就是 ASP.NET 异步页面的基本思路。实际上这个思路在 ASP.NET 1.1 时就已经提出，Fritz Onion 曾于 2003 年在 MSDN 杂志发表过一篇文章详细讨论这个问题，并给出了一个简单的解决方案。
Use Threads and Build Asynchronous Handlers in Your Server-Side Web Code
文中提供的实现，很好的对此问题进行原理上的验证。但从实现角度较为繁琐，需要自行处理 IAsyncResult 接口以及自定义线程池，而且缺少对 HTTP 上下文以及超时等的处理。
好在 ASP.NET 2.0 对此问题提供了内建的支持，Jeff Prosise 在 MSDN 杂志的文章中详细的讨论了其实现思路和使用方法。
Asynchronous Pages in ASP.NET 2.0
从使用角度来说，异步页面的支持非常透明。使用者只需要在页面定义的 Page 标签中指定异步模式，例如：
然后就可以在 Page 的实现代码中，通过 Page 类型的 AddOnPreRenderCompleteAsync 或 PageAsyncTask 方法，提交异步的页面处理代码。ASP.NET 引擎会根据页面的异步模式设定，调用合适的页面处理开始和结束方法。
对大多数简单的异步处理情况，可以直接调用 AddOnPreRenderCompleteAsync 方法，提交页面请求开始和结束时的处理代码，例如上述文章中给出的一个内部处理 HTTP 页面请求的例子：
1
//
AsyncPage.aspx.cs
2
using
System;
3
using
System.Web;
4
using
System.Web.UI;
5
using
System.Web.UI.WebControls;
6
using
System.Net;
7
using
System.IO;
8
using
System.Text;
9
using
System.Text.RegularExpressions;
10
11
public
partial
class
AsyncPage : System.Web.UI.Page
12
{
13
private WebRequest _request;
14
15 void Page_Load (object sender, EventArgs e)
16
{
17 AddOnPreRenderCompleteAsync (
18 new BeginEventHandler(BeginAsyncOperation),
19 new EndEventHandler (EndAsyncOperation)
20 );
21
}
22
23 IAsyncResult BeginAsyncOperation (object sender, EventArgs e,
24 AsyncCallback cb, object state)
25 {
26 _request = WebRequest.Create("http://msdn.microsoft.com");
27 return _request.BeginGetResponse (cb, state);
28 }
29 void EndAsyncOperation (IAsyncResult ar)
30 {
31 string text;
32 using (WebResponse response = _request.EndGetResponse(ar))
33 {
34 using (StreamReader reader =
35 new StreamReader(response.GetResponseStream()))
36 {
37 text = reader.ReadToEnd();
38 }
39 }
40
41 Regex regex = new Regex ("href\\s*=\\s*\"([^\"]*)\"",
42 RegexOptions.IgnoreCase);
43 MatchCollection matches = regex.Matches(text);
44
45 StringBuilder builder = new StringBuilder(1024);
46 foreach (Match match in matches)
47 {
48 builder.Append (match.Groups[1]);
49 builder.Append("<br/>");
50 }
51
52 Output.Text = builder.ToString ();
53 }
54
}
//
AsyncPage.aspx.cs
2
using
System;3
using
System.Web;4
using
System.Web.UI;5
using
System.Web.UI.WebControls;6
using
System.Net;7
using
System.IO;8
using
System.Text;9
using
System.Text.RegularExpressions;10
11
public
partial
class
AsyncPage : System.Web.UI.Page12
{
13
private WebRequest _request;14
15
void Page_Load (object sender, EventArgs e)16
{17
AddOnPreRenderCompleteAsync (18
new BeginEventHandler(BeginAsyncOperation),19
new EndEventHandler (EndAsyncOperation)20
);21
}22
23
IAsyncResult BeginAsyncOperation (object sender, EventArgs e, 24
AsyncCallback cb, object state)25
{26
_request = WebRequest.Create("http://msdn.microsoft.com");27
return _request.BeginGetResponse (cb, state);28
}29
void EndAsyncOperation (IAsyncResult ar)30
{31
string text;32
using (WebResponse response = _request.EndGetResponse(ar))33
{34
using (StreamReader reader = 35
new StreamReader(response.GetResponseStream()))36
{37
text = reader.ReadToEnd();38
}39
}40
41
Regex regex = new Regex ("href\\s*=\\s*\"([^\"]*)\"", 42
RegexOptions.IgnoreCase);43
MatchCollection matches = regex.Matches(text);44
45
StringBuilder builder = new StringBuilder(1024);46
foreach (Match match in matches)47
{48
builder.Append (match.Groups[1]);49
builder.Append("<br/>");50
}51
52
Output.Text = builder.ToString ();53
}54
}
AsyncPage 页面的 OnLoad 事件中提交异步处理方法；ASP.NET 引擎会在页面加载完成后，调用 BeginAsyncOperation 方法启动异步方法。这里的异步请求是打开一个远程 Web 页面，而大多数诸如数据库、WebService 调用等等，都提供了类似的异步调用版本。页面处理开始方法会返回异步调用请求的 IAsyncResult 封装，通过此接口检测处理的完成情况。而在 BeginAsyncOperation 方法返回之后，处理连接请求的线程将回到线程池，用来处理后续的连接请求。直到实际的异步处理操作完成，例如 Web 页面被取回，引擎才会从独立线程池中获取临时线程，调用 EndAsyncOperation 方法完成后续的操作。
其实际的处理流程如下图所示：
screen.width/2)this.style.width=screen.width/2;" border=0>
而 PageAsyncTask 的方式则是增强版本，除了异步页面处理开始和结束方法自身外，还可以提供在超时情况下的处理方法，以及处理时的状态对象。上述文章中给出的对应例子如下：
1
//
AsyncPageTask.aspx.cs
2
using
System;
3
using
System.Web;
4
using
System.Web.UI;
5
using
System.Web.UI.WebControls;
6
using
System.Net;
7
using
System.IO;
8
using
System.Text;
9
using
System.Text.RegularExpressions;
10
11
public
partial
class
AsyncPageTask : System.Web.UI.Page
12
{
13 private WebRequest _request;
14
15 protected void Page_Load(object sender, EventArgs e)
16 {
17 PageAsyncTask task = new PageAsyncTask(
18 new BeginEventHandler(BeginAsyncOperation),
19 new EndEventHandler(EndAsyncOperation),
20 new EndEventHandler(TimeoutAsyncOperation),
21 null
22 );
23 RegisterAsyncTask(task);
24 }
25
26 IAsyncResult BeginAsyncOperation(object sender, EventArgs e,
27 AsyncCallback cb, object state)
28 {
29 _request = WebRequest.Create("http://msdn.microsoft.com");
30 return _request.BeginGetResponse(cb, state);
31 }
32
33 void EndAsyncOperation(IAsyncResult ar)
34 {
35 string text;
36 using (WebResponse response = _request.EndGetResponse(ar))
37 {
38 using (StreamReader reader =
39 new StreamReader(response.GetResponseStream()))
40 {
41 text = reader.ReadToEnd();
42 }
43 }
44
45 Regex regex = new Regex("href\\s*=\\s*\"([^\"]*)\"",
46 RegexOptions.IgnoreCase);
47 MatchCollection matches = regex.Matches(text);
48
49 StringBuilder builder = new StringBuilder(1024);
50 foreach (Match match in matches)
51 {
52 builder.Append(match.Groups[1]);
53 builder.Append("<br/>");
54 }
55
56 Output.Text = builder.ToString();
57 }
58
59 void TimeoutAsyncOperation(IAsyncResult ar)
60 {
61 Output.Text = "Data temporarily unavailable";
62 }
63}
//
AsyncPageTask.aspx.cs
2
using
System;3
using
System.Web;4
using
System.Web.UI;5
using
System.Web.UI.WebControls;6
using
System.Net;7
using
System.IO;8
using
System.Text;9
using
System.Text.RegularExpressions;10
11
public
partial
class
AsyncPageTask : System.Web.UI.Page12
{13
private WebRequest _request;14
15
protected void Page_Load(object sender, EventArgs e)16
{17
PageAsyncTask task = new PageAsyncTask(18
new BeginEventHandler(BeginAsyncOperation),19
new EndEventHandler(EndAsyncOperation),20
new EndEventHandler(TimeoutAsyncOperation),21
null22
);23
RegisterAsyncTask(task);24
}25
26
IAsyncResult BeginAsyncOperation(object sender, EventArgs e, 27
AsyncCallback cb, object state)28
{29
_request = WebRequest.Create("http://msdn.microsoft.com");30
return _request.BeginGetResponse(cb, state);31
}32
33
void EndAsyncOperation(IAsyncResult ar)34
{35
string text;36
using (WebResponse response = _request.EndGetResponse(ar))37
{38
using (StreamReader reader = 39
new StreamReader(response.GetResponseStream()))40
{41
text = reader.ReadToEnd();42
}43
}44
45
Regex regex = new Regex("href\\s*=\\s*\"([^\"]*)\"", 46
RegexOptions.IgnoreCase);47
MatchCollection matches = regex.Matches(text);48
49
StringBuilder builder = new StringBuilder(1024);50
foreach (Match match in matches)51
{52
builder.Append(match.Groups[1]);53
builder.Append("<br/>");54
}55
56
Output.Text = builder.ToString();57
}58
59
void TimeoutAsyncOperation(IAsyncResult ar)60
{61
Output.Text = "Data temporarily unavailable";62
}63
}
为验证这一机制的实现效果，我们可以在各个方法的入口处设置断点。因为 VS2005 的 IDE 屏蔽了底层 CLR 实现信息，我们需要在 Debug\Windows\Immediate Window 窗口中，输入 .load sos 命令加载 CLR 调试支持。具体的 sos 命令可以输入 !help 查询帮助，或参考我以前《用WinDbg探索CLR世界》的系列文章，这里不再罗嗦。
在 AsyncPage 类型的 Page_Load、BeginAsyncOperation 和 EndAsyncOperation 方法中，分别输入 !ClrStack 命令可以获取当前线程的调用堆栈：
!clrstack
OS Thread Id: 0xb00 (2816)
ESP EIP
0361d9d4 05a9c817 AsyncPage.Page_Load(System.Object, System.EventArgs)
...
0361df34 050dd403 System.Web.HttpRuntime.ProcessRequest(System.Web.HttpWorkerRequest)
...
!clrstack
OS Thread Id: 0xb00 (2816)
ESP EIP
0361dc04 05a9d819 AsyncPage.BeginAsyncOperation(System.Object, System.EventArgs, System.AsyncCallback, System.Object)
...
0361df34 050dd403 System.Web.HttpRuntime.ProcessRequest(System.Web.HttpWorkerRequest)
...
!clrstack
OS Thread Id: 0xd30 (3376)
ESP EIP
04c5eee0 05fef30f AsyncPage.EndAsyncOperation(System.IAsyncResult)
...
04c5f60c 05fe976c System.Net.Connection.ReadComplete(Int32, System.Net.WebExceptionStatus)
...
可以看到 Page_Load 和 BeginAsyncOperation 方法都是在 ID 为 2816 的线程中被调用，其调用源也都是处理 HTTP 请求的 HttpRuntime.ProcessRequest 方法；而 EndAsyncOperation 则是在另外一个 ID 为 3376 的线程中调用，调用源也是完成网络读操作的 Connection.ReadComplete 方法。
而从实现角度来看，AddOnPreRenderCompleteAsync 方法将异步页面处理的启动和停止方法，放到一个 Page.PageAsyncInfo 对象中。此对象维护了与页面相关的各种上下文信息，以及开始、停止和状态的数组。而 RegisterAsyncTask 方法也是类似，将 PageAsyncTask 实例放到 PageAsyncTaskManager 类型的管理器中。
1
class
Page
2
{
3 private Page.PageAsyncInfo _asyncInfo;
4 private PageAsyncTaskManager _asyncTaskManager;
5
6 public void AddOnPreRenderCompleteAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state)
7 {
8 // 处理参数和状态异常情况
9
10 // 延迟构造异步页面信息
11 if (_asyncInfo == null)
12 _asyncInfo = new Page.PageAsyncInfo(this);
13
14 _asyncInfo.AddHandler(beginHandler, endHandler, state);
15 }
16
17 public void RegisterAsyncTask(PageAsyncTask task)
18 {
19 // 处理参数和状态异常情况
20
21 // 延迟构造异步任务管理器
22 if (this._asyncTaskManager == null)
23 _asyncTaskManager = new PageAsyncTaskManager(this);
24
25 _asyncTaskManager.AddTask(task);
26 }
27}
class
Page2
{3
private Page.PageAsyncInfo _asyncInfo;4
private PageAsyncTaskManager _asyncTaskManager;5
6
public void AddOnPreRenderCompleteAsync(BeginEventHandler beginHandler, EndEventHandler endHandler, object state)7
{8
// 处理参数和状态异常情况9
10
// 延迟构造异步页面信息11
if (_asyncInfo == null) 12
_asyncInfo = new Page.PageAsyncInfo(this); 13
14
_asyncInfo.AddHandler(beginHandler, endHandler, state);15
}16
17
public void RegisterAsyncTask(PageAsyncTask task)18
{19
// 处理参数和状态异常情况20
21
// 延迟构造异步任务管理器22
if (this._asyncTaskManager == null)23
_asyncTaskManager = new PageAsyncTaskManager(this);24
25
_asyncTaskManager.AddTask(task);26
}27
}
HttpApplication 在处理页面请求时，通过其 pipeline 的 CallHandlerExecutionStep 步骤，调用页面的 BeginProcessRequest 方法，其伪代码如下：
1
void
HttpApplication.IExecutionStep.Execute()
2
{
3 // 从上下文中获取获取当前页面的处理器
4 HttpContext context = _application.Context;
5 IHttpHandler handler = context.Handler;
6
7 if (handler == null)
8 {
9 _sync = true;
10 }
11 else if (handler is IHttpAsyncHandler)
12 {
13 // 如果是异步处理器，则调用异步处理开始方法
14 IHttpAsyncHandler asyncHandler = (IHttpAsyncHandler) handler1;
15
16 _sync = false;
17 _handler = asyncHandler;
18
19 IAsyncResult result = asyncHandler.BeginProcessRequest(context, _completionCallback, null);
20
21 // 如果的确是异步操作，就直接返回
22 if (!result.CompletedSynchronously)
23 return;
24
25 // 否则恢复同步的页面处理流程
26 _sync = true;
27 _handler = null;
28 asyncHandler.EndProcessRequest(result);
29 }
30 else
31 {
32 // 采用同步模式处理页面
33 _sync = true;
34
35 _application.SyncContext.SetSyncCaller();
36 try
37 {
38 handler.ProcessRequest(context);
39 }
40 finally
41 {
42 _application.SyncContext.ResetSyncCaller();
43 }
44 }
45}
void
HttpApplication.IExecutionStep.Execute()2
{3
// 从上下文中获取获取当前页面的处理器4
HttpContext context = _application.Context;5
IHttpHandler handler = context.Handler;6
7
if (handler == null)8
{9
_sync = true;10
}11
else if (handler is IHttpAsyncHandler)12
{13
// 如果是异步处理器，则调用异步处理开始方法14
IHttpAsyncHandler asyncHandler = (IHttpAsyncHandler) handler1;15
16
_sync = false;17
_handler = asyncHandler;18
19
IAsyncResult result = asyncHandler.BeginProcessRequest(context, _completionCallback, null);20
21
// 如果的确是异步操作，就直接返回 22
if (!result.CompletedSynchronously)23
return;24
25
// 否则恢复同步的页面处理流程26
_sync = true;27
_handler = null;28
asyncHandler.EndProcessRequest(result);29
}30
else31
{32
// 采用同步模式处理页面33
_sync = true;34
35
_application.SyncContext.SetSyncCaller();36
try37
{38
handler.ProcessRequest(context);39
}40
finally41
{42
_application.SyncContext.ResetSyncCaller();43
}44
}45
}
而 ASP.NET 页面一旦通过 Page 标记定义为异步模式，其编译生成的 Page 子类就会实现 IHttpAsyncHandler 接口。
例如对上述例子，我们可以通过 !ClrStack 命令看到页面被编译为名称为 ASP.asyncpage_aspx 的类型。
!clrstack
OS Thread Id: 0xb00 (2816)
ESP EIP
0361d9d4 05a9c817 AsyncPage.Page_Load(System.Object, System.EventArgs)
...
0361dd5c 0545b90e System.Web.UI.Page.AsyncPageBeginProcessRequest(System.Web.HttpContext, System.AsyncCallback, System.Object)
0361dd98 0545b813 ASP.asyncpage_aspx.BeginProcessRequest(System.Web.HttpContext, System.AsyncCallback, System.Object)
0361ddec 0545b6b6 System.Web.HttpApplication+CallHandlerExecutionStep.System.Web.HttpApplication.IExecutionStep.Execute()
0361de28 05400c18 System.Web.HttpApplication.ExecuteStep(IExecutionStep, Boolean ByRef)
...
进一步使用 !DumpDomain 命令可以找到其页面编译的临时文件，如
!DumpDomain
...
Assembly: 0023ade0 [D:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files\asyncpage\ba0a3865\3cd7d92\App_Web_n97gem4v.dll]
ClassLoader: 0023abc0
SecurityDescriptor: 00229ac0
Module Name
05a502cc D:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files\asyncpage\ba0a3865\3cd7d92\App_Web_n97gem4v.dll
...
使用 IL 反汇编根据打开此文件，可以看到 AsyncPage.aspx 被编译为 asyncpage_aspx 类型，如下所示：
1
public
class
asyncpage_aspx : AsyncPage, IHttpAsyncHandler, IHttpHandler
2
{
3 public virtual IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object data)
4 {
5 return base.AsyncPageBeginProcessRequest(context, cb, data);
6 }
7
8 public virtual void EndProcessRequest(IAsyncResult ar)
9 {
10 base.AsyncPageEndProcessRequest(ar);
11 }
12}
13
14
public
interface
IHttpAsyncHandler : IHttpHandler
15
{
16 // Methods
17 IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData);
18 void EndProcessRequest(IAsyncResult result);
19}
public
class
asyncpage_aspx : AsyncPage, IHttpAsyncHandler, IHttpHandler2
{3
public virtual IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object data)4
{5
return base.AsyncPageBeginProcessRequest(context, cb, data);6
}7
8
public virtual void EndProcessRequest(IAsyncResult ar)9
{ 10
base.AsyncPageEndProcessRequest(ar);11
}12
}
13
14
public
interface
IHttpAsyncHandler : IHttpHandler15
{16
// Methods17
IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData);18
void EndProcessRequest(IAsyncResult result);19
}
其中 AsyncPage 类型是后台实现代码编译生成的类型，asyncpage_aspx 则是 .aspx 页面编译生成。
而在 Page.AsyncPageBeginProcessRequest 方法中，将首先处理上下文环境初始化，初始化异步执行信息，以及相应回调函数的执行；然后会调用 PageAsyncTaskManager.RegisterHandlersForPagePreRenderCompleteAsync 将异步任务管理器中所有的异步任务，封装后注册到 Page.PageAsyncInfo 对象中维护的异步调用信息中；最后调用 其 CallHandlers 方法完成对异步处理开始方法的调用。完整的伪代码如下：
1
class
Page
2
{
3 protected IAsyncResult AsyncPageBeginProcessRequest(HttpContext context, AsyncCallback callback, object extraData)
4 {
5 // 处理上下文环境初始化
6
7 // 初始化异步执行信息
8 _asyncInfo.AsyncResult = new HttpAsyncResult(callback, extraData);
9 _asyncInfo.CallerIsBlocking = callback == null;
10
11 // 执行相应回调函数
12
13 // 注册异步任务
14 if ((_asyncTaskManager != null) && !_asyncInfo.CallerIsBlocking)
15 _asyncTaskManager.RegisterHandlersForPagePreRenderCompleteAsync();
16
17 // 调用所有的异步处理开始方法
18 _asyncInfo.CallHandlers(true);
19
20 return _asyncInfo.AsyncResult;
21 }
22}
class
Page2
{3
protected IAsyncResult AsyncPageBeginProcessRequest(HttpContext context, AsyncCallback callback, object extraData)4
{5
// 处理上下文环境初始化6
7
// 初始化异步执行信息8
_asyncInfo.AsyncResult = new HttpAsyncResult(callback, extraData);9
_asyncInfo.CallerIsBlocking = callback == null;10
11
// 执行相应回调函数12
13
// 注册异步任务14
if ((_asyncTaskManager != null) && !_asyncInfo.CallerIsBlocking) 15
_asyncTaskManager.RegisterHandlersForPagePreRenderCompleteAsync();16
17
// 调用所有的异步处理开始方法18
_asyncInfo.CallHandlers(true);19
20
return _asyncInfo.AsyncResult; 21
}22
}
而在 PageAsyncTaskManager 中被管理的异步任务，会作为一个异步执行信息注册到 PageAsyncInfo 中去。并在其被调用时，实际调用 PageAsyncTaskManager 类型的 ExecuteTasks 方法，实现较为复杂的异步调用逻辑。
1
internal
class
PageAsyncTaskManager
2
{
3 internal void RegisterHandlersForPagePreRenderCompleteAsync()
4 {
5 _page.AddOnPreRenderCompleteAsync(new BeginEventHandler(this.BeginExecuteAsyncTasks), new EndEventHandler(this.EndExecuteAsyncTasks));
6 }
7
8 private IAsyncResult BeginExecuteAsyncTasks(object sender, EventArgs e, AsyncCallback cb, object extraData)
9 {
10 return ExecuteTasks(cb, extraData);
11 }
12
13 private void EndExecuteAsyncTasks(IAsyncResult ar)
14 {
15 _asyncResult.End();
16 }
17}
internal
class
PageAsyncTaskManager2
{3
internal void RegisterHandlersForPagePreRenderCompleteAsync()4
{5
_page.AddOnPreRenderCompleteAsync(new BeginEventHandler(this.BeginExecuteAsyncTasks), new EndEventHandler(this.EndExecuteAsyncTasks));6
}7
8
private IAsyncResult BeginExecuteAsyncTasks(object sender, EventArgs e, AsyncCallback cb, object extraData)9
{10
return ExecuteTasks(cb, extraData);11
}12
13
private void EndExecuteAsyncTasks(IAsyncResult ar)14
{15
_asyncResult.End();16
}17
}
以上我们对异步页面的目的、范围、使用方式和实现原理等，有了一个大致的了解。并针对异步任务的管理做了简要的分析，基本上已经能弄清异步页面的静态运行机制如何。下一节我们将从动态执行的角度，对两级异步任务，以及相应的调度和线程使用做进一步探索。
to be continue...
