而在以稳定见长的Windows Server 2008服务器系统中,该功能默认被禁用,当然您如果正在把WS2008当成台式机系统来用的话,建议重新开启SuperFetch以取得更高的性能,方法如下:

　　注册表位置做如下修改:

　　[HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlSession ManagerMemory ManagementPrefetchParameters]

　　"EnableSuperfetch"=dword:00000003

　　"EnablePrefetcher"=dword:00000001

运行 regedit 打开注册表

、找到 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management\PrefetchParameters 这个注册表项
    新建 dword项 名称为 EnablePrefetcher 数值为 3

打开 服务 ，将SuperFetch设为 自动 可以立刻启动成功

base.DataBind（pageIndex）;

PROC
1CREATE PROC sp_PageView
2 @tbname     sysname,               --要分页显示的表名
3 @FieldKey   nvarchar(1000),      --用于定位记录的主键(惟一键)字段,可以是逗号分隔的多个字段
4 @PageCurrent int=1,               --要显示的页码
5 @PageSize   int=10,                --每页的大小(记录数)
6 @FieldShow nvarchar(1000)='',      --以逗号分隔的要显示的字段列表,如果不指定,则显示所有字段
7 @FieldOrder nvarchar(1000)='',      --以逗号分隔的排序字段列表,可以指定在字段后面指定DESC/ASC,用于指定排序顺序
8 @Where    nvarchar(1000)='',     --查询条件
9 @ItemCount int OUTPUT,
10 @PageCount int OUTPUT             --总页数
11 AS
12 SET NOCOUNT ON
13 --检查对象是否有效
14 IF OBJECT_ID(@tbname) IS NULL
15 BEGIN
16     RAISERROR(N'对象"%s"不存在',1,16,@tbname)
17     RETURN
18 END
19 IF OBJECTPROPERTY(OBJECT_ID(@tbname),N'IsTable')=0
20     AND OBJECTPROPERTY(OBJECT_ID(@tbname),N'IsView')=0
21     AND OBJECTPROPERTY(OBJECT_ID(@tbname),N'IsTableFunction')=0
22 BEGIN
23     RAISERROR(N'"%s"不是表、视图或者表值函数',1,16,@tbname)
24     RETURN
25 END
26 --分页字段检查
27 IF ISNULL(@FieldKey,N'')=''
28 BEGIN
29     RAISERROR(N'分页处理需要主键（或者惟一键）',1,16)
30     RETURN
31 END
32 --其他参数检查及规范
33 IF ISNULL(@PageCurrent,0)<1 SET @PageCurrent=1
34 IF ISNULL(@PageSize,0)<1 SET @PageSize=10
35 IF ISNULL(@FieldShow,N'')=N'' SET @FieldShow=N'*'
36 IF ISNULL(@FieldOrder,N'')=N''
37     SET @FieldOrder=N''
38 ELSE
39     SET @FieldOrder=N'ORDER BY '+LTRIM(@FieldOrder)
40 IF ISNULL(@Where,N'')=N''
41     SET @Where=N''
42 ELSE
43     SET @Where=N'WHERE ('+@Where+N')'
44 --如果@PageCount为NULL值,则计算总页数(这样设计可以只在第一次计算总页数,以后调用时,把总页数传回给存储过程,避免再次计算总页数,对于不想计算总页数的处理而言,可以给@PageCount赋值)
45
46     DECLARE @sql nvarchar(4000)
47     SET @sql=N'SELECT @ItemCount=COUNT(*)'
48         +N' FROM '+@tbname
49         +N' '+@Where
50     EXEC sp_executesql @sql,N'@ItemCount int OUTPUT',@ItemCount OUTPUT
51     SET @PageCount=(@ItemCount+@PageSize-1)/@PageSize
52
53 print @PageCount
54 print @ItemCount
55 --计算分页显示的TOPN值
56 DECLARE @TopN varchar(20),@TopN1 varchar(20)
57 SELECT @TopN=@PageSize,
58     @TopN1=(@PageCurrent-1)*@PageSize
59 --第一页直接显示
60 IF @PageCurrent=1
61     EXEC(N'SELECT TOP '+@TopN
62         +N' '+@FieldShow
63         +N' FROM '+@tbname
64         +N' '+@Where
65         +N' '+@FieldOrder)
66 ELSE
67 BEGIN
68     --处理别名
69     IF @FieldShow=N'*'
70         SET @FieldShow=N'a.*'
71     --生成主键(惟一键)处理条件
72     DECLARE @Where1 nvarchar(4000),@Where2 nvarchar(4000),
73         @s nvarchar(1000),@Field sysname
74     SELECT @Where1=N'',@Where2=N'',@s=@FieldKey
75     WHILE CHARINDEX(N',',@s)>0
76         SELECT @Field=LEFT(@s,CHARINDEX(N',',@s)-1),
77             @s=STUFF(@s,1,CHARINDEX(N',',@s),N''),
78             @Where1=@Where1+N' AND a.'+@Field+N'=b.'+@Field,
79             @Where2=@Where2+N' AND b.'+@Field+N' IS NULL',
80             --@Where=REPLACE(@Where,@Field,N'a.'+@Field),
81             @FieldOrder=REPLACE(@FieldOrder,@Field,N'a.'+@Field),
82             @FieldShow=REPLACE(@FieldShow,@Field,N'a.'+@Field)
83     SELECT --@Where=REPLACE(@Where,@s,N'a.'+@s),
84        @FieldOrder=REPLACE(@FieldOrder,@s,N'a.'+@s),
85        @FieldShow=REPLACE(@FieldShow,@s,N'a.'+@s),
86         @Where1=STUFF(@Where1+N' AND a.'+@s+N'=b.'+@s,1,5,N''),   
87        @Where2=CASE
88            WHEN @Where='' THEN N'WHERE ('
89            ELSE @Where+N' AND ('
90            END+N'b.'+@s+N' IS NULL'+@Where2+N')'
91    DECLARE @QUERYSTRING varchar(2000)
92    SET @QUERYSTRING =     N'SELECT TOP '+@TopN
93        +N' '+@FieldShow
94        +N' FROM '+@tbname
95        +N' a LEFT JOIN(SELECT TOP '+@TopN1
96        +N' '+@FieldKey
97        +N' FROM '+@tbname
98        +N' a '+@Where
99        +N' '+@FieldOrder
100        +N')b ON '+@Where1
101        +N' '+@Where2
102        +N' '+@FieldOrder
103    PRINT @QUERYSTRING   
104    --执行查询
105    EXEC(@QUERYSTRING)
106
107
108END
109GO
转自：http://www.cnblogs.com/double1030/archive/2009/01/22/1379717.html

算法

private static int Partition(ref int[] dest, int be, int en, ref int swapTimes)
{
int temp = dest[en];
int b = be;
int e = en;
while(b != e)
{
while(dest[b] < temp && b < e)
b ++;
if(b < e)
{
dest[e] = dest[b];
e --;
swapTimes ++;
}

while(dest[e] > temp && b < e)
{
e --;
}
if(b < e)
{
dest[b] = dest[e];
b ++;
swapTimes ++;
}
}

dest[b] = temp;
return b;

}   

3：请简述面向对象的多态的特性及意义！
在c#中多态性的定义是：同一操作作用于不同的类的实例、不同的类将进行不同的解释、最后产生不同的执行结果。

c#支持两种类型的多态性：
编译时的多态性（静态联编）
编译时的多态性是通过重载来实现的。方法重载和操作符重载、它们都实现了编译时的多态性。
对于非虚的成员来说系统在编译时根据传递的参数、返回的类型等信息决定实现何种操作。
运行时的多态性（动态联编）
运行时的多态性就是指直到系统运行时才根据实际情况决定实现何种操作c#中运行时的多态性。
通过虚成员实现。
编译时的多态性为我们提供了运行速度快的特点而运行时的多态性则带来了高度灵活和抽象的特点。

4：session喜欢丢值且占内存，Cookis不安全，请问用什么办法代替这两种原始的方法
    用VIEWSTATE /Profile/自己在服务器端实现个Cache
5：对数据的并发采用什么办法进行处理较好。
   １、使用事务对象：

1SqlConnection   conn   =   new   SqlConnection(ConnectionString);  
2 SqlCommand   cmd   =   new   SqlCommand("delete   from   table_a   where   bh=1",conn);  
3 SqlTransaction   Trans   ;　　　//事物对象  
4   
5 conn.Open();  
6 Trans   =   conn.BeginTransaction(IsolationLevel.ReadCommitted,   "MyTrans");  
7 cmd.Transaction   =   Trans;  
8 try{  
9 cmd.ExecuteNonQuery();  
10                    //如果成功，则提交数据  
11 Trans.Commit();  
12 }  
13 catch   (SqlException   Err){  
14                  //产生错误，则回滚事物对象  
15 Trans.Rollback("MyTrans");  
16 }  
17 finally{  
18 conn.Close();  
19 }  
2、 使用lock() unlock()
3、使用时间戳，使用ｔｉｍｅｔａｍｐ类型。
6：已知Oracle数据库有GD和ZS两个数据库，GD数据库v_s表有数据写入时，从v_s表中提取最新数据到ZS数据库的D_E表中。请问用什么办法解决这一问题？如果又碰到不能互访的问题时，又用什么办法解决？

答案:1:触发器
2:不能互访时,肯定是权限出了问题,可以对v_s表赋予D_E表的操作权限

7：已知Oracle数据库a,b
现在在a用户权限下，访问b数据库sql语句为select a.* From b a,请改正这一句Sql的写法

答案:select * From b.TableName  

8：当对数据库进行海量级的数据插入时，数据库出现报错，错误原因可能有哪些，以你的经验谈谈你的解决办法

答案:1:数据库表空间不足,因为Oracle必须指定表空间的大小 更改表空间大小,如果装有双机热备则必须对物理存贮文件进行手工更改
2:表死锁 采用脚本形式对表解锁
3:监听丢失,重启监听解决  

9：算法分析
AH 20060625 12 44 01 CAD001
AH 20060625 12 44 01 CAD001
AH 20060625 13 44 02 CAD001
AH 20060625 14 44 03 CAD001
说明：第二列表示日期，第三列表示温度，第四列表示水位，第五列表示流量，第6列表示水位测站编码,每一列表示一个字段
很明显第一条数据和第二条数据重复，然数据表中有主键和外键的约束，是不允许有重复的数据存在的,请构造算法将重复的数据Del掉

select distinct * into #Tmp from tableName
drop table tableName
select * into tableName from #Tmp
drop table #Tmp

10:javascript算法
已知a,b,现在点鼠标a会向b游动,鼠标停,a会停下来
请实现"跑步算法"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
　　1， 请你说说.NET中类和结构的区别?

　　答：结构和类具有大体的语法，但是结构受到的限制比类要多。结构不能申明有默认的构造函数，为结构的副本是又编译器创建和销毁的，所以不需要默认的构造函数和析构函数。结构是值类型，所以对结构变量所做的改变不会影响其的原值，而类是应用类型，改变其变量的值会改变其原值。申明结构用Struck关键字，申明类用class关键字，向方法传递结构是时是通过值传递的，而不是通过引用。与类不同，结构的实例化可以不使用New关键字。类可以实现接口。

　　2， 死锁的必要条件?怎么克服?

　　答：系统的资源不足，进程的推进的顺序不合适，资源分配不当，一个资源每次只能被一个进程使用，一个资源请求资源时，而此时这个资源已阻塞，对已获得资源不放，进程获得资源时，未使用完前，不能强行剥夺。

　　3， 接口是否可以继承接口?抽象类是否可以实现接口?抽象类是否可以继承实体类?

　　答：接口是可以继承接口的，抽象类是可以实现接口的，抽象类可以继承实体类，但是有个条件，条件是，实体类必须要有明确的构造函数。

　　4， 构造器Constructor是否可以被继承?是否可以被Override?

　　答：Constructor不可以被继承，因此不能被重写(Overriding)，但可以被重载(Overloading).

　　5， 当一个线程进入一个对象的方法后，其它线程是否可以进入该对象的方法?

　　答：不可以，一个对象的方法只能由一个线程访问。

　　6， 用最有效的方法算出等已8对于几?

　　答：2<<3.

　　7, C#是否可以对内存直接进行操作?

　　答：这个问题比较难回答，也是个很大的问题。但是可以这样问答。C#是可以对内存进行直接操作的，虽然很少用到指针，但是C#是可以使用指针的，在用的时候需要在前边加unsafe,，在.net中使用了垃圾回收机制(GC)功能，它替代了程序员，不过在C#中不可以直接使用finalize方法，而是在析构函数中调用基类的finalize()方法。

　　8， Error和Exception有是区别?

　　答：error表示恢复不是不可能，但是很困难，exception表示一种实际或实现问题，它表示程序运行正常不可以发生的。

　　9， 谈谈final,finally,finallize的区别?

　　答：final用于申明属性，方法和类，表示属性不可变，方法不可以被覆盖，类不可以被继承。

　　Finally是异常处理语句结构中，表示总是执行的部分。

　　Finallize表示是object类一个方法，在垃圾回收机制中执行的时候会被调用被回收对象的方法。

　　10, HashMap和Hashtable区别?

　　答：HashMap是Hashtable的轻量级实现，非线程安全的实现他们都实现了map接口，主要区别是HashMap键值可以为空null,效率可以高于Hashtable。

　　11，Collection和Collections的区别?

　　答：Collection是集合类的上级接口，Collections是针对集合类的一个帮助类，它提供一系列静态方法来实现对各种集合的搜索，排序，线程安全化操作。

　　12，C#中委托是什么?事件是不是一种委托?

　　答：委托是一种安全的类似与函数指针，但是她比指针要安全的多，它可以把方法作为一个参数传递给另一个方法，可以理解为指向函数的引用。事件是一种消息机制，它是一种委托，委托不带方法体。

　　13，Override, Overload,的区别?

　　答：Override是重写的意思，它表示重写基类的方法，而且方法的名称，返回类型，参数类型，参数个数要与基类相同。

　　Overload是重载是意思，它也表示重写基类的方法，但是只要方法名相同，别的可以不同。

　　14，在一个BS结构中需要传递变量值时，不能使用session,coolke,application,你有几中方法?

　　答：this.server.Transfer,Querystring.

　　15, C#种索引器实现过程，是否只能根据数字索引?

　　答：不是的，可以是任意类型。

　　16，New有种用法?

　　答：有3种，第一种是，实例化如：New Class()

　　第二种是，public new 隐藏基类的方法

　　第三种是，在泛型类申明中的任何类型参数都必须有公共的无参构造函数。

　　17，任何把一个Array复制到Arraylist中?

　　答：Foreach (object o in Array), ArrayList.Add (0)

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/opou/archive/2009/07/27/4385590.aspx

var item = $('input[@name=items][@checked]').val();
获取select被选中项的文本
var item = $("select[@name=items] option[@selected]").text();
select下拉框的第二个元素为当前选中值
$('#select_id')[0].selectedIndex = 1;
radio单选组的第二个元素为当前选中值
$('input[@name=items]').get(1).checked = true;

获取值：

文本框，文本区域：$("#txt").attr("value")；
多选框checkbox：$("#checkbox_id").attr("value")；
单选组radio： $("input[@type=radio][@checked]").val();
下拉框select： $('#sel').val();

控制表单元素：
文本框，文本区域：$("#txt").attr("value",'');//清空内容
$("#txt").attr("value",'11');//填充内容

多选框checkbox： $("#chk1").attr("checked",'');//不打勾
$("#chk2").attr("checked",true);//打勾
if($("#chk1").attr('checked')==undefined) //判断是否已经打勾

单选组radio： $("input[@type=radio]").attr("checked",'2');//设置value=2的项目为当前选中项
下拉框select： $("#sel").attr("value",'-sel3');//设置value=-sel3的项目为当前选中项
$("<option value='1'>1111</option><option value='2'>2222</option>").appendTo("#sel")//添加下拉框的option
$("#sel").empty()；//清空下拉框

//控制表单元素：
//文本框，文本区域：
$("#text_id").attr("value",'');//清空内容
$("#text_id").attr("value",'test');//填充内容
//多选框checkbox：
$("#chk_id").attr("checked",'');//未选中的值
$("#chk_id").attr("checked",true);//选中的值
if($("#chk_id").attr('checked')==undefined) //判断是否已经选中
//单选组radio：
$("input[@type=radio]").attr("checked",'10');//设置value=10的单选按钮为当前选中项
//下拉框select：
$("#select_id").attr("value",'test');//设置value=test的项目为当前选中项
$("<option value='test'>test</option><option value='test2'>test2</option>").appendTo("#select_id")//添加下拉框的option
$("#select_id").empty()；//清空下拉框

一．      设置web.config相关选项

先启用窗体身份验证和默认登陆页,如下。

<authentication mode="Forms">

       <forms loginUrl="default.aspx"></forms>

</authentication>

设置网站可以匿名访问，如下

<authorization>

           <allow users="*" />

</authorization>

然后设置跟目录下的admin目录拒绝匿名登陆，如下。注意这个小节在System.Web小节下面。

     <location path="admin">

       <system.web>

           <authorization>

              <deny users="?"></deny>

           </authorization>

       </system.web>

</location>

把http请求和发送的编码设置成GB2312,否则在取查询字符串的时候会有问题，如下。

<globalization requestEncoding="gb2312" responseEncoding="gb2312" />

设置session超时时间为1分钟，并启用cookieless，如下。

<sessionState mode="InProc" cookieless="true" timeout="1" />

为了启用页面跟踪，我们先启用每一页的trace，以便我们方便的调试，如下。

<trace enabled="true" requestLimit="1000" pageOutput="true" traceMode="SortByTime" localOnly="true" />

二．      设置Global.asax文件

处理Application_Start方法，实例化一个哈西表，然后保存在Cache里

    protected void Application_Start(Object sender, EventArgs e)

    {

       Hashtable h=new Hashtable();

       Context.Cache.Insert("online",h);

}

    在Session_End方法里调用LogoutCache()方法，方法源码如下

/// <summary>

    /// 清除Cache里当前的用户,主要在Global.asax的Session_End方法和用户注销的方法里调用      /// </summary>

    public void LogoutCache()

    {

       Hashtable h=(Hashtable)Context.Cache["online"];

       if(h!=null)

       {

           if(h[Session.SessionID]!=null)

           h.Remove(Session.SessionID);

           Context.Cache["online"]=h;

       }

}

三．      设置相关的登陆和注销代码

登陆前调用PreventRepeatLogin()方法，这个方法可以防止用户重复登陆，如果上次用户登陆超时大于1分钟，也就是关闭了所有admin目录下的页面达到60秒以上，就认为上次登陆的用户超时，你就可以登陆了，如果不超过60秒，就会生成一个自定义异常。在Cache["online"]里保存了一个哈西表,哈西表的key是当前登陆用户的SessionID,而Value是一个ArrayList,这个ArrayList有两个元素,第一个是用户登陆的名字第二个元素是用户登陆的时间,然后在每个admin目录下的页刷新页面的时候会更新当前登陆用户的登陆时间,而只admin目录下有一个页打开着,即使不手工向服务器发送请求,也会自动发送一个请求更新登陆时间,下面我在页面基类里写了一个函数来做到这一点,其实这会增加服务器的负担,但在一定情况下也是一个可行的办法.

/// <summary>

       /// 防止用户重复登陆,在用户将要身份验证前使用

       /// </summary>

       /// <param name="name">要验证的用户名字</param>

       private void PreventRepeatLogin(string name)

       {

           Hashtable h=(Hashtable)Cache["online"];

           if(h!=null)

           {

              IDictionaryEnumerator e1=h.GetEnumerator();

              bool flag=false;

              while(e1.MoveNext())

              {                

                  if((string)((ArrayList)e1.Value)[0]==name)

                  {

                     flag=true;

                     break;

                  }

              }

              if(flag)

              {

                  TimeSpan ts=System.DateTime.Now.Subtract(Convert.ToDateTime(((ArrayList)e1.Value)[1]));

                  if(ts.TotalSeconds<60)

                     throw new oa.cls.MyException("对不起，你输入的账户正在被使用中，如果你是这个账户的真正主人，请在下次登陆时及时的更改你的密码，因为你的密码极有可能被盗窃了!");

                  else

                     h.Remove(e1.Key);       

              }

           }

           else

           {

              h=new Hashtable();

           }

           ArrayList al=new ArrayList();

           al.Add(name);

           al.Add(System.DateTime.Now);

           h[Session.SessionID]=al;

           if(Cache["online"]==null)

           {

              Context.Cache.Insert("online",h);

           }else

              Cache["Online"]=h;         

    }

用户注销的时候调用上面提到LogoutCache()方法

四．      设置admin目录下的的所有页面的基类

using System;

using System.Web;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Web.UI.HtmlControls;

using System.Collections;

namespace oa.cls

{

    public class MyBasePage : System.Web.UI.Page

    {

       /// <summary>

       /// 获取本页是否在受保护目录,我这里整个程序在OA的虚拟目录下,受保护的目录是admin目录

       /// </summary>

       protected bool IsAdminDir

       {

           get

           {

              return Request.FilePath.IndexOf("/oa/admin")==0;

           }

       }

       /// <summary>

       /// 防止session超时,如果超时就注销身份验证并提示和转向到网站默认页

       /// </summary>

       private void PreventSessionTimeout()

       {

           if(!this.IsAdminDir) return;

           if(Session["User_Name"]==null&&this.IsAdminDir)

           {            

              System.Web.Security.FormsAuthentication.SignOut();

              this.Alert("登陆超时",Request.ApplicationPath)

           }

       }

       /// <summary>

       /// 每次刷新本页面的时候更新Cache里的登陆时间选项,在下面的OnInit方法里调用.

       /// </summary>

       private void UpdateCacheTime()

       {

           Hashtable h=(Hashtable)Cache["online"];

           if(h!=null)

           {

              ((ArrayList)h[Session.SessionID])[1]=DateTime.Now;

           }

           Cache["Online"]=h;

       }

       /// <summary>

       /// 在跟踪里输出一个HashTable的所有元素,在下面的OnInit方法里调用.以便方便的观察缓存数据

       /// </summary>

       /// <param name="myList"></param>

       private void TraceValues( Hashtable myList)

       {

           IDictionaryEnumerator myEnumerator = myList.GetEnumerator();

           int i=0;

           while ( myEnumerator.MoveNext() )

           {

              Context.Trace.Write( "onlineSessionID"+i, myEnumerator.Key.ToString());

              ArrayList al=(ArrayList)myEnumerator.Value;

              Context.Trace.Write( "onlineName"+i, al[0].ToString());

              Context.Trace.Write( "onlineTime"+i,al[1].ToString());

              TimeSpan ts=System.DateTime.Now.Subtract(Convert.ToDateTime(al[1].ToString()));

               Context.Trace.Write("当前的时间和此登陆时间间隔的秒数",ts.TotalSeconds.ToString());

              i++;

           }

       }

       /// <summary>

       /// 弹出信息并返回到指定页

       /// </summary>

       /// <param name="msg">弹出的消息</param>

       /// <param name="url">指定转向的页面</param>

       protected void Alert(string msg,string url)

       {

           string scriptString = "<script language=JavaScript>alert(\""+msg+"\");location.href=\""+url+"\"</script>";

           if(!this.IsStartupScriptRegistered("alert"))

              this.RegisterStartupScript("alert", scriptString);

       }

       /// <summary>

       /// 为了防止常时间不刷新页面造成会话超时,这里写一段脚本,每隔一分钟向本页发送一个请求以维持会话不被超时，这里用的是xmlhttp的无刷新请求

       /// 这个方法也在下面的OnInit方法里调用

       /// </summary>

       protected void XmlReLoad()

       {     

           System.Text.StringBuilder htmlstr=new System.Text.StringBuilder();

           htmlstr.Append("<SCRIPT LANGUAGE=\"JavaScript\">");

           htmlstr.Append("function GetMessage(){");

           htmlstr.Append(" var xh=new ActiveXObject(\"Microsoft.XMLHTTP\");");

           htmlstr.Append(" xh.open(\"get\",window.location,false);");

           htmlstr.Append(" xh.send();");

           htmlstr.Append(" window.setTimeout(\"GetMessage()\",60000);");

           htmlstr.Append("}");

           htmlstr.Append("window.onload=GetMessage();");

           htmlstr.Append("</SCRIPT>       ");

           if(!this.IsStartupScriptRegistered("xmlreload"))

              this.RegisterStartupScript("alert", htmlstr.ToString());

       }

       override protected void OnInit(EventArgs e)

       {

           base.OnInit(e);

           this.PreventSessionTimeout();

           this.UpdateCacheTime();

           this.XmlReLoad();

           if(this.Cache["online"]!=null)

           {

              this.TraceValues((System.Collections.Hashtable)Cache["online"]);

           }

       }

    }

}

五．      写一个自定义异常类

首先要在跟目录下写一个错误显示页面ShowErr.aspx，这个页面根据传递过来的查询字符串msg的值，在一个Label上显示错误信息。

using System;

namespace oa.cls

{

    /// <summary>

    /// MyException 的摘要说明。

    /// </summary>

    public class MyException:ApplicationException

    {

           /// <summary>

           /// 构造函数

           /// </summary>

           public MyException():base()

           {

           }

           /// <summary>

           /// 构造函数

           /// </summary>

           /// <param name="ErrMessage">异常消息</param>

           public MyException(string Message):base(Message)

           {

               System.Web.HttpContext.Current.Response.Redirect("~/ShowErr.aspx?msg="+Message);

           }

           /// <summary>

           /// 构造函数

           /// </summary>

           /// <param name="Message">异常消息</param>

           /// <param name="InnerException">引起该异常的异常类</param>

           public MyException(string Message,Exception InnerException):base(Message,InnerException)

           {

           }

       }

}

六．总结

我发现在Session里保存的值，比如session["name"]是没有任何向服务器的请求达到1分钟后就会自动丢失,但是session ID是关闭同一进程的浏览器页面后达1分钟后才会丢失并更换的,因为只要你开着浏览器就会有session ID,无论是在url里保存还是在cookies里。不知道这个结论对不对，反正我在设置了session的timeout为1分钟后，session["name"]的值已经没有了，可是SessionID还是旧的，Global.asax里的Session_End里的代码也没有执行，而身份验证票据也没有丢失。我不知道这三者之间的关系是怎样的，谁先谁后，好像在<authentication>小节可以设置一个timeout属性，不过项目赶的紧，我没时间研究了。

以上这些代码比较零散，我花费了2天的时间才总结出来这套方案，不是很完美，但是暂时只能这样了，不能在这方面浪费很多时间了，大家可以把上面的代码组织到一个类里，然后把方法都修改成静态方法方便调用。

System;

System.Data;

System.Configuration;

System.Collections;

System.Web;

System.Web.Security;

System.Web.UI;

System.Web.UI.WebControls;

System.Web.UI.WebControls.WebParts;

System.Web.UI.HtmlControls;

/// <summary>
/// 说明：事件被缓存的示例
/// 作者：文野
/// 联系：stwyhm.cnblogs.com
/// </summary>

CacheEvent : System.Web.UI.Page

{
    protected void Page_Load(object sender, EventArgs e)
    {

     }
    
    /**//// <summary>
    /// 说明：文本框的TextChanged事件，不会自动引发页面Postback
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void TextBox1_TextChanged(object sender, EventArgs e)
    {
         Response.Write("引发了文本框的TextChanged事件。<br />");
     }

    /**//// <summary>
    /// 说明：下拉框的SelectedIndexChanged事件，不会自动引发页面Postback
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void DropDownList1_SelectedIndexChanged(object sender, EventArgs e)
    {
         Response.Write("引发了下拉框SelectedIndexChanged事件。<br />");
     }

    /**//// <summary>
    /// 说明：按钮的Click事件，引发页面Postback
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Button1_Click(object sender, EventArgs e)
    {
         Response.Write("引发了按钮的Click事件。<br />");
     }
}

    由上面的示例我们看到，当按钮事件引发Postback时同时被缓存的另两个事件也运行了。

参考资料
    《ASP.NET服务器控件高级编程》
    《Visual Basic .NET Power Coding》

    《ASP.NET服务器控件与组件开发》

    《ASP.NET深入解析》

本文源码
    下载

事件体系结构

引发事件的对象叫做事件源。事件源发布它可以引发的事件。事件的类型总是委托类型，这个委托类型的签名定义了处理该事件的方法的签名。定义事件处理程序方法的对象称为事件接收方。事件接收方预订要在事件源上处理的事件事件接收方提供的事件处理程序方法必须与为该事件预订的方法签名一致。事件源利用多播委托跟踪这些事件处理程序方法。当发生重要情况时，事件源引发事件，当事件引发后，事件源自动利用它的金手委托调用在每个事件接收方上指定的事件处理程序方法。

事件和委托的关系

一个事件（Event）是一个对象发送的一个消息，用来表示一个动作发生了。而一个动作可以被用户操作或者其他程序所触发。触发事件的对象被事件发送者（Event Sender）调用：捕获处理事件的对象被事件接收者（Event Receiver）调用。

在事件通信中，事件的发送者不知道哪个对象或者方法将要去接收／处理发送过去的事件。因而在事件源和事件接收者之间就需要一个中间人存在，这个中间人就叫委托。

在使用事件的有效范围里，委托提供一种机制，在事件引发时为类指示要调用的方法。当事件引发时，使用委托作为被调用方法的指针，修改事件的类就不需要了解作为观测程序的类的任何信息。

定义事件

在连接事件和其处理程序方法之前，需要定义一个其他对象关心的事件。用event关键字和指示方法签名的委托对象来定义事件，这个事件的所有事件处理程序都得遵循该委托对象指示的方法签名。

public event EventHandler Click;

根据约定，引发事件的行为在OnEventName方法中发生。

        public void OnClick(EventArgs e)
        {
            // 如果为事件注册了处理程序则引发该程序
            if (Click != null)
            {
                 Click(this, e);
             }
         }

先进行检查，以确定存在事件，否则值为null。接着像调用方法一样调用事件来引发它，把对控件或类的this传递给它，指示它作为事件的发送者，把一个EventArgs类的新实例作为第二个参数。

使用事件

声明了事件和它相应的委托之后，希望对事件作出响应的对象就必须为这个事件添加一个事件处理程序。事件处理程序是一个方法，它的签名和与事件关联的委托相匹配，当事件引发的时候被调用。

Object.EventName += new DelegateType(EventHandlerMethod);

    注意：当指派多个处理程序给一个事件的时候，处理程序的调用次序是没有保证的。因此不要指望处理程序会以一个特定次序出现。

EventHandler与EventArgs

EventHandler是.NET Framework中预定了一个用于事件的委托，它有两个参数：object类型参数以及System.EventArgs类型的参数。Object对象代表了事件发送者，EventArgs对象代表了事件包含的事件数据。

其实所有的事件处理方法都只有这两个参数，惟一不同的是，其他的某些事件处理方法的第二个参数会是System.EventArgs的一个子类，用于自定义一些我们需要的事件参数。

ASP.NET事件模型

ASP.NET的事件驱动是一种基于HTTP协议的技术，在ASP.NET中事件的触发和事件的处理是分别在客户端和服务器端进行的。一个事件在客户端被触发之后，会通过HTTP协议以POST的方式发送到服务器端，而服务器端则通过ASP.NET页面架构来进行相应的处理和反馈。

缓存事件
    ASP.NET Framework提供给服务器端事件不是很多，因为事件驱动模型机制的实现是在客户端和服务器端分别实现的，之间需要通过HTTP协议方式来传递事件信息，因而如果频繁地触发各类事件会对整个Web站点产生很大的流量压力（如OnMouseOver事件）。但是，有些事件虽然也会频繁的触发但是必须提供（如Change事件），对于这种情况，ASP.NET Framework提供了一个折衷的办法，就是对于这类事件在触发时，不是立即将事件信息发送到服务器，而是缓存在客户端，等到再一次的事件信息被发送到服务器端时一同发送回去。因此，当这些缓存着的事件以及刚刚被触发的事件在服务器端被接收时，ASP.NET Framework不会按照特定的顺序去解释执行处理这些事件。

这是一个我自认为比较经典的委托示例（给排序算法传递一个动态比较的函数）。

using System;

using System.Collections.Generic;

using System.Text;

namespace MyDelegateTest

{

     /// <summary>

     /// 说明：给排序算法传递一个动态比较函数的委托示例

     /// 作者：文野

     /// 联系：stwyhm.cnblogs.com

     /// </summary>

     // 进行排序的委托

     public delegate bool Compare(int left, int right);

     public class DelegateSample

     {

         private int[] items;

         public int[] Items

         {

              set { items = value; }

              get { return items; }

         }

         // 比大

         public bool Greater(int left, int right)

         {

              return left > right;

         }

         // 比小

         public bool Less(int left, int right)

         {

              return !Greater(left, right);

         }

         public void Sort(Compare compare)

         {

              for (int i = 0; i < items.Length-1; i++)

              {

                   for (int j = i + 1; j < items.Length; j++)

                   {

                       if (compare(items[i], items[j]))

                       {

                            int tmp = items[i];

                            items[i] = items[j];

                            items[j] = tmp;

                       }

                   }

              }

         }

     }

}

委托实际上是类（一个貌似函数一样的类），我们已经使用函数指针很多年了——函数指针也被称为过程类型，但是它们的实现都不是类。它们是单独的函数指针的简单实例。委托是包含这些功能的类，委托类通过保留的列表来确定某些事物是否已经指派给了委托，这种算法可以理解为：“对于内部列表中的每一个回调函数，都调用函数”。委托除了支持回调函数外，还可以通过该列表来实现多播（委托链）。

说白了，就是我们把一批具有相同特征的方法，通过建立与具有同样相同特征的委托的一个实例来进行传递，以使其它地方能对这些方法进行调用。即把方法当作参数进行传递（浅显的认识，勿笑）。

初识委托

示例1：

using System;

using System.Collections.Generic;

using System.Text;

using System.Web;

namespace MyDelegateTest

{

     /// <summary>

     /// 说明：一个简单的委托示例

     /// 作者：文野

     /// 联系：stwyhm.cnblogs.com

     /// </summary>

     // 新建一个用以输出消息的委托

     public delegate void WriteMessage();

     public class WriteToWeb

     {

         // 一个输出消息的静态方法

         public static void StaticWrite()

         {

              HttpContext.Current.Response.Write("委托调用了一个静态方法。<br />");

         }

         // 一个输出消息的类实例方法

         public void Write()

         {

              HttpContext.Current.Response.Write("委托调用了一个类实例方法。<br />");

         }

     }

}

调用：

protected void Page_Load(object sender, EventArgs e)

    {

         // 新建一个委托，回调函数是一个静态方法

         WriteMessage wm = new WriteMessage(WriteToWeb.StaticWrite);

         WriteToWeb w = new WriteToWeb();

         // 新建一个委托并与加到先前建立的委托组成委托链，回调函数是一个类实例方法

         wm += new WriteMessage(w.Write);

         // 执行委托链上所有的回调函数

         wm();

    }

上面的示例程序首先建立了一个简单得不能再简单的用以输出的委托，下面的类中有两个与委托签名一致的方法（一个静态方法，一个类实例方法）。下面的调用过程首先建立了一个使用回调静态方法的委托，其后又建立了一个使用类实例方法的委托并与先前的委托组成了一个委托链，最后执行委托链上所有的方法。

由此可见，委托最简单的理解就是利用与方法签名一致的委托，可以把方法当作参数一样来传递，无论是静态方法还是类实例方法。

委托的秘密

从上面的类视图中我们看到，对委托的定义最终被编译成一个类，这个类中定义有4种方法：构造器，Invoke，BeginInvoke，EndInvoke。

所有的委托都继承自MulticastDelegate，而MulticastDelegate又继续至Delegate。这样我们定义的委托自然也就继承了MulticastDelegate的字段、属性和方法。在继承得到的所有成员中，有3个最重要的字段：

1、_target：指向调用回调函数时应该操作的对象。该字段用于实例方法的回调。

2、_methodPtr：一个内部的整数值，CLR用它来识别回调的方法。

3、_prev：指向另一个委托对象。

当编译器知道我们在构造的是一个委托时，它会分析源代码来确定要引用哪个对象和方法。其中对象引用会被传递给_target(对于静态方法，_target被置为null)，一个特殊的标识方法的Int32值会被传递给_methodPtr，_prev在构造器中被置为null，它被用于在委托链中记录下一个委托的引用。

每个委托对象实际上是对方法及其调用操作的一个包装，MulticastDelegate中定义了两个只读属性，Target和Method，Target（其实就是前面的_target字段）属性返回一个方法回调时操作的对象的引用，Method属性返回一个标识回调方法的System.Reflection.MethodInfo对象。

委托链

前面介绍过MulticastDelegate中有一个_prev的私有字段，这个字段指向另一个MulticastDelegate对象的引用，这样就实现了委托链（其实与我们在学链表时的实现方式是一致的）。

当委托链表被调用时，它首先会调用委托中在其前面的委托对象，这里如果被调的回调方法具有返回值，将被丢失，委托链只会返回最后一次调用回调方法的返回值。

HTTP运行期处理客户端应用程序（例如Web浏览器）进入的一个Web请求，通过处理它的应用程序的适当组件路由请求，然后产生响应并发回提出请求的客户端应用程序。

进入的HTTP Web请求最先由IIS Web服务器接收到，它在此请求基于ASP.NET已注册处理的扩展名传送到ASP.NET ISAPI上。

HTTP运行期首先创建一个HttpContext对象的实例，它包含了当前正在处理的请求信息，接着创建在处理逻辑中涉及到的所有其他组件都可以使用的上下文对象。HttpContext实例提供了对请求对象（HttpRequest类的实例）和响应对象（HttpResponse类的实例）的访问。

HTTP运行期集成由称为HTTP模块（HTTP Module）的组件构成的处理管线，用于执行请求预处理动作（如：高速缓存的查询和授权）和后处理动作（如：更新调整缓存）。这些组件实现IHttpModule接口。在管线中，每个模块处理不同的全局应用层次和特定请求事件来执行其逻辑。

HTTP运行期基于请求的URL还选择一个HTTP处理程序（实现IHttpHandler接口的组件）或HTTP处理程序工厂（实现IHttpHandlerFactory接口的组件）来完成引入请求的实际处理过程。处理程序用HttpContext对象来收集请求信息、并写出响应的结果。

图1：ASP.NET Web 应用程序中的请求处理过程

一个HTTP请求的处理过程

当一个HTTP请求被送入HttpRuntime之后，这个HTTP请求会继续被送入到一个被称为HttpApplicationFactory的容器中。而这个窗口会给出一个HttpApplication实例来处理传递进来的HTTP请求，而后这个HTTP请求会依次进入如下几个容器中：

HttpModule ——> HttpHandler Factory ——> HttpHandler

当系统内部的HttpHandler的ProcessResquest的方法处理完毕之后，整个Http Request就被处理完成了，客户端也就得到相应的结果了。

一个完整的HTTP请求在ASP.NET Framework的处理过程如下：

HttpRequest ——> inetinfo.exe ——> ASPNET_ISAPI.dll ——> Http Pipeline ——> ASPNET_WP.exe ——> HttpRuntime ——> HttpApplication Factory ——> HttpApplication ——> HttpModule ——> HttpHandler Factory ——> HttpHandler ——> HttpHandler.ProcessRequest()

页面执行模型

页面执行模型由页面HTTP处理程序工厂开始，它注册HTTP运行期以为所有.aspx文件处理请求。页面处理程序工厂负责创建一个Page对象的实例，这是将最终处理请求所生成响应结果的HTTP处理程序。

首先页面处理程序工厂尝试在与请求的.aspx文件相关的.NET高速缓存内查找以前编译过的页面类。当查找失败时，就像第一次请求一样，处理程序工厂将读取和解析文件，并创建一棵解析树（parse tree）。解析树类似于控件树，但是并不包含控件，解析树包含称为控件生成器（control builder）的对象实例。控件生成器包含了在解析过程期间收集的相关控件信息。然后通过Page指令中的Language attribute，用与页面相关的语言把解析树转变为代码。然后，页面处理程序工厂调用适当的编译程序，动态地编译从Page中得到的类，页面处理程序工厂还将新建的类放置到ASP.NET调整缓存中，并且把高速缓存记录和文件相关性关联起来。文件相关性监视.aspx文件做出的变化，并保证任何变化都自动地使高速缓存记录无效，在下次请求时这些记录将再次解析修改过的文件。

图2：页面如何处理请求

参考资料
    《ASP.NET服务器控件与组件开发》
    《ASP.NET深入解析》

using System;

using System.Collections.Generic;

using System.Text;

using System.Web;

namespace MyHandler

{

    public class MyHandlerFactory : IHttpHandlerFactory

    {

        #region IHttpHandlerFactory 成员

        public IHttpHandler GetHandler(HttpContext context, string requestType, string url, string pathTranslated)

        {

            string fname = url.Substring(url.IndexOf('/') + 1);

            while (fname.IndexOf('/') != -1)

                fname = fname.Substring(fname.IndexOf('/') + 1);

            string cname = fname.Substring(0, fname.IndexOf('.'));

            string className = "MyHandler." + cname;

            object h = null;

            try

            {

                // 采用动态反射机制创建相应的IHttpHandler实现类。

                h = Activator.CreateInstance(Type.GetType(className));

            }

            catch (Exception e)

            {

                throw new HttpException("工厂不能为类型"+cname+"创建实例。",e);

            }

            return (IHttpHandler)h;

        }

        public void ReleaseHandler(IHttpHandler handler)

        {

        }

        #endregion

    }

    public class Handler1 : IHttpHandler

    {

        #region IHttpHandler 成员

        public bool IsReusable

        {

            get { return true; }

        }

        public void ProcessRequest(HttpContext context)

        {

            context.Response.Write("<html><body><h1>来自Handler1的信息。</h1></body></html>");

        }

        #endregion

    }

    public class Handler2 : IHttpHandler

    {

        #region IHttpHandler 成员

        public bool IsReusable

        {

            get { return true; }

        }

        public void ProcessRequest(HttpContext context)

        {

            context.Response.Write("<html><body><h1>来自Handler2的信息。</h1></body></html>");

        }

        #endregion

    }

}

参考资料

《ASP.NET深入解析》

本文源码：

下载

HttpHandler是一个HTTP请求的真正处理中心，也正是在这个HttpHandler容器中，ASP.NET Framework才真正地对客户端请求的服务器页面做出编译和执行，并将处理过后的信息附加在HTTP请求信息流中再次返回到HttpModule中。

IHttpHandler是什么

IHttpHandler定义了如果要实现一个HTTP请求的处理所必需实现的一些系统约定。HttpHandler与HttpModule不同，一旦定义了自己的HttpHandler类，那么它对系统的HttpHandler的关系将是“覆盖”关系。

IHttpHandler如何处理HTTP请求

当一个HTTP请求经同HttpModule容器传递到HttpHandler容器中时，ASP.NET Framework会调用HttpHandler的ProcessRequest成员方法来对这个HTTP请求进行真正的处理。以一个ASPX页面为例，正是在这里一个ASPX页面才被系统处理解析，并将处理完成的结果继续经由HttpModule传递下去，直至到达客户端。

对于ASPX页面，ASP.NET Framework在默认情况下是交给System.Web.UI.PageHandlerFactory这个HttpHandlerFactory来处理的。所谓一个HttpHandlerFactory，所谓一个HttpHandlerFactory，是指当一个HTTP请求到达这个HttpHandler Factory时，HttpHandlerFactory会提供出一个HttpHandler容器，交由这个HttpHandler容器来处理这个HTTP请求。

一个HTTP请求都是最终交给一个HttpHandler容器中的ProcessRequest方法来处理的。

图1：ProcessRequest方法

一个简单的HttpHandler容器

通过实现IHttpHandler接口可以创建自定义HTTP处理程序，该接口只包含两个方法。通过调用IsReusable，IHttpHandlerFactory可以查询处理程序以确定是否可以使用同一实例为多个请求提供服务。ProcessRequest方法将HttpContext实例用作参数，这使它能够访问Request和Response内部对象。在一个HttpHandler容器中如果需要访问Session，必须实现IRequiresSessionState接口，这只是一个标记接口，没有任何方法。

示例1：

using System;

using System.Collections.Generic;

using System.Text;

using System.Web;

using System.Web.SessionState;

namespace MyHandler

{

    /// <summary>

    /// 目的：实现一个简单的自定义HttpHandler容器

    /// 作者：文野

    /// 联系：stwyhm@cnblogs.com

    /// </summary>

    public class MyFirstHandler : IHttpHandler,IRequiresSessionState

    {

        #region IHttpHandler 成员

        public bool IsReusable

        {

            get { return true; }

        }

        public void ProcessRequest(HttpContext context)

        {

            context.Response.Write("<h1><b>Hello HttpHandler</b></h1>");

            context.Session["Test"] = "测试HttpHandler容器中调用Session";

            context.Response.Write(context.Session["Test"]);

        }

        #endregion

    }

}

在Web.config中加入如下配置：

<httpHandlers>

     <add verb="*" path="*" type="MyHandler.MyFirstHandler, MyHandler"/>

</httpHandlers>

IHttpHandler工厂

ASP.NET Framework实际不直接将相关的页面资源HTTP请求定位到一个其内部默认的IHttpHandler容器之上，而定位到了其内部默认的IHttpHandler工厂上。IHttpHandler工厂的作用是对IHttpHandler容器进行调度和管理。

IHttpHandlerFactory接口包含两个方法。GetHandler返回实现IHttpHandler接口的类的实例，ReleaseHandler使工厂可以重用现有的处理程序实例。

多个自定义的Http Module的运作

从运行结果可以看到，在web.config文件中引入自定义HttpModule的顺序就决定了多个自定义HttpModule在处理一个HTTP请求的接管顺序。注：系统默认那几个HttpModule是最先衩ASP.NET Framework所加载上去的。

示例3：（代码类同示例2）

在HttpModule中终止此次的HTTP请求

可以利用HttpModule通过调用HttpApplication.CompleteRequest()方法实现当满足某一个条件时终止此次的HTTP请求。

需要注意的是，即使调用了HttpApplication.CompleteRequest()方法终止了一个HTTP请求，ASP.NET Framework仍然会触发HttpApplication后面的这3个事件：EndRequest事件、PreSendRequestHeaders事件、PreSendRequestContent事件。

如果存在多个自定义的HttpModule的话，当Module1终止了一个HTTP请求，这个HTTP请求将不会再触发Module2中相应的事件了，但Module2的最后三个事件仍会被触发。

示例4：

using System;

using System.Collections.Generic;

using System.Text;

using System.Web;

namespace MyHttpModule

{

    public class CompleteRequestHttpModule : IHttpModule

    {

        #region IHttpModule 成员

        public void Dispose()

       {}

        public void Init(HttpApplication application)

        {

            application.BeginRequest += new EventHandler(Application_BeginRequest);

        }

        void Application_BeginRequest(object sender, EventArgs e)

        {

            HttpApplication application = (HttpApplication)sender;

            application.CompleteRequest();

            application.Context.Response.Write("请求被终止。");

        }

        #endregion

    }

}

参考资料

《ASP.NET深入解析》

《ASP.NET实用全书》

本文源码：
    下载

当一个HTTP请求到达HttpModule时，整个ASP.NET Framework系统还并没有对这个HTTP请求做任何处理，也就是说此时对于HTTP请求来讲，HttpModule是一个HTTP请求的“必经之路”，所以可以在这个HTTP请求传递到真正的请求处理中心（HttpHandler）之前附加一些需要的信息在这个HTTP请求信息之上，或者针对截获的这个HTTP请求信息作一些额外的工作，或者在某些情况下干脆终止满足一些条件的HTTP请求，从而可以起到一个Filter过滤器的作用。

示例1：

using System;

using System.Collections.Generic;

using System.Text;

using System.Web;

namespace MyHttpModule

{

     /// <summary>

     /// 说明：用来实现自己的HttpModule类。

     /// 作者：文野

     /// 联系：stwyhm@cnblogs.com

     /// </summary>

     public class MyFirstHttpModule : IHttpModule

     {

         private void Application_BeginRequest(object sender, EventArgs e)

         {

              HttpApplication application = (HttpApplication)sender;

              HttpContext context = application.Context;

              HttpRequest request = application.Request;

              HttpResponse response = application.Response;

              response.Write("我来自自定义HttpModule中的BeginRequest<br />");

         }

         private void Application_EndRequest(object sender, EventArgs e)

         {

              HttpApplication application = (HttpApplication)sender;

              HttpContext context = application.Context;

              HttpRequest request = application.Request;

              HttpResponse response = application.Response;

              response.Write("我来自自定义HttpModule中的EndRequest<br />");

         }

         #region IHttpModule 成员

         public void Dispose()

         {}

         public void Init(HttpApplication application)

         {

              application.BeginRequest += new EventHandler(Application_BeginRequest);

              application.EndRequest += new EventHandler(Application_EndRequest);

         }

         #endregion

     }

}

在Web.config进行如下配置

<add name="MyFirstHttpModule" type="MyHttpModule.MyFirstHttpModule,MyHttpModule"/>

深入了解HttpModule

一个HTTP请求在HttpModule容器的传递过程中，会在某一时刻（ResolveRequestCache事件）将这个HTTP请求传递给HttpHandler容器。在这个事件之后，HttpModule容器会建立一个HttpHandler的入口实例，但是此时并没有将HTTP请求控制权交出，而是继续触发AcquireRequestState事件以及PreRequestHandlerExcute事件。在PreRequestHandlerExcute事件之后，HttpModule窗口就会将控制权暂时交给HttpHandler容器，以便进行真正的HTTP请求处理工作。

而在HttpHandler容器内部会执行ProcessRequest方法来处理HTTP请求。在容器HttpHandler处理完毕整个HTTP请求之后，会将控制权交还给HttpModule，HttpModule则会继续对处理完毕的HTTP请求信息流进行层层的转交动作，直到返回到客户端为止。

图1：HttpModule生命周期示意图