ASP.NET 执行顺序 等等

http://www.cnblogs.com/cyan/archive/2009/02/04/1383580.html

:

ASP.Net处理Http Request时，使用Pipeline（管道）方式，由各个HttpModule对请求进行处理，然后到达 HttpHandler，HttpHandler处理完之后，仍经过Pipeline中各个HttpModule的处理，最后将HTML发送到客户端浏览器中。

生命周期中涉及到几个非常重要的对象：HttpHandler，HttpModule，IHttpHandlerFactory，他们的执行顺序大致的执行过程是这样的：

client端发送页面请求，被IIS的某个进程截获，它根据申请的页面后缀(.aspx)不同，调用不同的页面处理程序(.asp->asp.dll; .aspx->ISAPI.dll)。而页面处理程序在处理过程中，则要经历HttpModule，HttpHandler的处理：前者HttpModule用于页面处理前和处理后的一些事件的处理，后者HttpHandler进行真正的页面的处理。
如前所说，HttpModule会在页面处理前和后对页面进行处理，所以它不会影响真正的页面请求。通常用在给每个页面的头部或者尾部添加一些信息（如版权声明）等。曾经见过一些免费的空间，我们的页面上传上去后，浏览的时候发现，在每个页面的头部和尾部多了很多小广告....如果理解了HttpModule的原理，要做这个就不是很难了~

IHttpModule与IHttpHandler的区别整理
1.先后次序.先IHttpModule,后IHttpHandler. 注:Module要看你响应了哪个事件，一些事件是在Handler之前运行的，一些是在Handler之后运行的
2.对请求的处理上:
   IHttpModule是属于大小通吃类型,无论客户端请求的是什么文件,都会调用到它;例如aspx,rar,html的请求.
   IHttpHandler则属于挑食类型,只有ASP.net注册过的文件类型(例如aspx,asmx等等)才会轮到调用它.
3.IHttpHandler按照你的请求生成响应的内容，IHttpModule对请求进行预处理，如验证、修改、过滤等等，同时也可以对响应进行处理

 

ASP.Net系统本身配置有很多HttpHandler和HttpModule，以处理aspx等.Net标准的页面文件，以及这些页面文件中标准的事件处理等。查看

%System%/Microsoft.NET\Framework\v2.0.50727\CONFIG目录下的 web.config文件中的httpHandlers和httpModules节点，可以看到这些配置。如果有兴趣，可以使用Reflector查看.Net系统中相关的类和方法，了解.Net如何处理以及做了什么处理。

.Net也提供了一套机制来开发自定义的HttpHandler和 HttpModule，均可以用于对HttpRequest的截取，完成自定义的处理。 HttpModule 继承System.Web.IHttpModule接口，实现自己的HttpModule类。必须要实现接口的两个方法：Init和Dispose。在 Init中，可以添加需要截取的事件；Dispose用于资源的释放，如果在Init中创建了自己的资源对象，请在Dispose中进行释放。

namespace MyModule

{

    public class MyHttpModule : IHttpModule

    {

        public MyHttpModule()

        {

        }

        //Init方法用来注册HttpApplication 事件。

        public void Init(HttpApplication r_objApplication)

        {

            r_objApplication.BeginRequest += new EventHandler(this.BeginRequest);

        }

        public void Dispose()

        {

        }

        private void BeginRequest(object r_objSender, EventArgs r_objEventArgs)

        {

            HttpApplication objApp = (HttpApplication)r_objSender;

            objApp.Response.Write("您请求的URL为" + objApp.Request.Path);

        }

    }

} 

将编译的dll文件拷贝到web项目的bin目录下，在web项目的web.config文件system.web节点中配置：

    <httpModules>

      <add name="test" type="MyModule.MyHttpModule,MyHttpModule"/>

    </httpModules>
    这样就将自定义的HttpModule类MyHttpModule插入到了当前web的HttpModule的Pipeline中。 HttpModule主要功能是对Application的各个事件进行截取，在这些事件中完成自己的处理。其实如果自己开发一些项目，直接在 Global.asax中处理已经足够了。如果是开发一个Framework或者是某些方面的组件，需要在事件中添加处理，开发自定义的 HttpModule，可以避免使用Framework或者组件时，还得手工在Global.asax中添加代码。目前想到的开发自定义HttpModule的用途，有全局的身份/权限验证、自定义网站访问/操作日志的记录、处于管理/调试等目的对站点进行监控追踪等。当然，如果是结合自定义的HttpHandler进行Framework的开发，HttpModule可以用于其它的一些特殊的处理。注意要区分大小写，因为web.config作为一个XML文件是大小写敏感的。“type=MyHttpModuleTest.MyHttpModule,MyHttpModule”告诉我们系统将会将http request请求交给位于MyHttpModule.dll文件中的MyHttpModuleTest.MyHttpModule类去处理。HttpHandler是完全的对Http Request的截取。
    首先，继承System.Web.IHttpHandler接口，实现自己的HttpHandler类。必须要实现接口的ProcessRequest方法和IsReusable属性。ProcessRequest方法中完成对每个Http Request的处理，发送处理结果的HTML到输出缓存中。IsReusable属性被.Net Framework调用，用以确定这个HttpHandler的实例是否可以被重用于同类型其它的Request处理。
    如果你在自己的HttpHandler类中，需要读取或者是写Session值，需要再继承一个接口IRequiresSessionState。这个接口没有任何方法，只是一个标记接口。继承这个接口之后，就可以在自己的HttpHandler中访问Session，可以在Session中写入值。

 

namespace MyHandler

{

    public class MyHttpHandler : IHttpHandler, IRequiresSessionState

    {

        public MyHttpHandler() { }

        public bool IsReusable

        {

            get { return true; }

        }

        public void ProcessRequest(HttpContext context)

        {

            HttpResponse objResponse = context.Response;

            objResponse.Write("This request is handled by MyHttpHandler");

        }

    }

}

    把编译的dll文件拷贝到web项目的bin目录下。
    接下来，这样来测试一下MyHttpHandler。我们为IIS配置一个以.cc为后缀名的文件类型，用我们写的MyHttpHandler来处理。
    首先，在IIS站点的Configuration配置里面，添加一个对.cc后缀名处理的Application Extention Mapping项。   
    然后，在web项目的web.config节点中配置：

    <httpHandlers>

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

    </httpHandlers> 

    verb属性配置这个HttpHandler处理那些HTTP方法，例如GET、POST等，如果是处理所有方法，就用*。path属性配置HttpHandler对哪些文件进行处理，例如可以是myfile.cc，如果是处理所有的.cc文件，就用*.cc。
    这样，这个站点上所有.cc类型文件的访问，都由MyHttpHandler处理。使用http://localhost/站点虚拟目录/a.cc访问测试站点，可以看到测试效果。当然，a.cc这个文件在Web服务器上是并不存在的。

    对HttpHandler的使用，比较典型的有.Net的Web MVC开源项目Maverick。Maverick使用一个Dispatcher类对所有的Http Request进行截取，他以.m作为后缀名向Web服务器提交请求，在Dispatcher中，将.m的后缀去掉，提取Command Name，然后以这个command name从配置文件中加载处理的flow，形成一个chain，依次对chain上的各个command和view进行处理，对各个command和 view的处理结果可能会在chain中选择不同的处理分支，每个处理的Step中将处理结果的HTML写入Response的缓存中进行输出。
    总体来说，Maverick的框架架构概念很不错，但也存在明显的缺陷，以后有时间再详细的写写它的架构和需要改进之处。

    总之，将HttpModule、HttpHandler，以及使用Ajax等将客户端进行封装结合起来，能够给web项目的开发带来非常大的改善空间。

我们经常看到很多网站访问文章的时候才用的是***.html 或***.shtml (如本blog的日志访问效果)，其时这写文件在服务器上不存在的，那为什么会出现这样的效果呢，是因为Web服务器上对URL执行了重写，把访问的 URL根据特定的格式重写成内部访问页面来实现的，它的好处是便于用户理解，同时搜索引擎也能更好地收入你的网站，当然其它的好处也很多，这里不做一一介 绍了。 
本文所讲的是使用Asp.Net中的HttpHandler实现URL重写的，它所实现的原理请看这里，本程序可以处理任何Url，因为我在程序中使用了URL过虑，只有访问文件名是数字的才进行处理，并指在内部执行一个新的页面，并输出数据，代码如下：

        public void ProcessRequest(HttpContext Context)

        {

            try

            {

                //申明Request        

                HttpRequest Request = Context.Request;

                //取来路Url的绝对路径       

                string Url = Request.Url.AbsolutePath;

                //取访问的Web文件的开始字符间隔数

                int RegStart = Url.LastIndexOf("/") + 1;

                //申明一个确定Web文件名是否全是数字

                Regex Reg = new Regex(@"\d+");

                //用正则表达式进行匹配

                if (Reg.IsMatch(Url, RegStart))

                {

                    //如果web文件名是数字，则判定是查询相关文章，执行指定页面

                    Context.Server.Execute("~/PermaLink.aspx?id=" + Reg.Match(Url, RegStart).Value);

                }

            }

            catch

            {

                Context.Response.Redirect(Context.Request.Url.ToString());

            }

        }

当然你首先要做的是先建一个类，并继承自IHttpHandler，然后把这段代码拷入，并编译。在Web项目中若要使用此功能，需要在web.config里面加上如下语句：

     <httpHandlers>

      <add verb="*" path="*.shtml" type="HttpHandle.UrlRewrite" />

</httpHandlers>

同时，还要在IIS中对Web项目进行配置，在Web项目的属性中，在主目录选项卡里，把执行权限改为"脚本和可执行文件"，然后打开配置，在应用程序扩展里加上需重写的文件格式的扩展。好了，万事具备，只欠运行了。

 

================================================================================================================================================================

http://www.cnblogs.com/zhangleong/archive/2011/04/26/2029588.html

HttpApplication触发事件来通知你的程序有事发生,以此来负责请求流转.这作为HttpApplication.Init()函数的一部分发生(用Reflector查看System.Web.HttpApplication.InitInternal()方法和HttpApplication.ResumeSteps()方法来了解更多详情),连续设置并启动一系列事件,包括执行所有的处理器(handler).这些事件处理器映射到global.asax中自动生成的哪些事件中,同时它们也映射到所有附加的HttpModule(它们本质上是HttpApplication对外发布的额外的事件接收器(sink)).

　　HttpModule和HttpHandler两者都是根据Web.config中对应的配置被动态载入并附加到事件处理链中.HttpModule实际上是事件处理器,附加到特殊的HttpApplication事件上,然而HttpHandler是用来处理”应用级请求处理”的终点.

　　HttpModule和HttpHandler两者都是在HttpApplication.Init()函数调用的一部分中被载入并附加到调用链上.

HttpContext, HttpModules 和 HttpHandlers

　　httpApplication它本身对发送给应用程序的数据一无所知-它只是一个通过事件来通讯的消息对象.它触发事件并通过HttpContext对象来向被调用函数传递消息.实际的当前请求的状态数据由前面提到的HttpContext对象维护.它提供了所有请求专有的数据并从进入管道开始到结束一直跟随请求.图7显示了ASP.NET管道中的流程.注意上下文对象(即HttpContext),这个从请求开始到结束一直都是你”朋友”的对象,可以在一个事件处理函数中保存信息并在以后的事件处理函数中取出.

　　一旦管道被启动,HttpApplication开始象图六那样一个个的触发事件.每个事件处理器被触发,如果事件被挂接,这些处理器将执行它们自己的任务.这个处理的主要任务是最终调用挂接到此特定请求的HttpHandler.处理器(handler)是ASP.NET请求的核心处理机制,通常也是所有应用程序级别的代码被执行的地方.记住ASP.NET页面和Web服务框架都是作为HttpHandler实现,这里也是处理请求的的核心之处.模块(module)趋向于成为一个传递给处理器(handler)的上下文的预处理或后处理器.ASP.NET中典型的默认处理器包括预处理的认证,缓存以及后处理中各种不同的编码机制.

　　有很多关于HttpHandler和HttpModule的可用信息,所以为了保持这篇文章在一个合理的长度,我将提供一个关于处理器的概要介绍.

　　HttpModule

　　当请求在管道中传递时,HttpApplicaion对象中一系列的事件被触发.我们已经看到这些事件在Global.asax中作为事件被发布.这种方法是特定于应用程序的,可能并不总是你想要的.如果你要建立一个通用的可用被插入任何Web应用程序的HttpApplication事件钩子,你可用使用HttpModule,这是可复用的,不需要特定语应用程序代码的,只需要web.config中的一个条目.

　　模块本质上是过滤器(fliter)-功能上类似于ISAPI过滤器,但是它工作在ASP.NET请求级别上.模块允许为每个通过HttpApplication对象的请求挂接事件.这些模块作为外部程序集中的类存贮.,在web.config文件中被配置,在应用程序启动时被载入.通过实现特定的接口和方法,模块被挂接到HttpApplication事件链上.多个HttpModule可用被挂接在相同的事件上,事件处理的顺序取决于它们在Web.config中声明的顺序.下面是在Web.config中处理器定义.

＜configuration＞
     ＜system.web＞
          ＜httpModules＞
               ＜add name= "BasicAuthModule"  type="HttpHandlers.BasicAuth,WebStore" /＞
          ＜/httpModules＞
     ＜/system.web＞
＜/configuration＞

　　注意你需要指定完整的类型名和不带dll扩展名的程序集名.

　　模块允许你查看每个收到的Web请求并基于被触发的事件执行一个动作.模块在修改请求和响应数据方面做的非常优秀,可用为特定的程序提供自定义认证或者为发生在ASP.NET中的每个请求增加其他预处理/后处理功能.许多ASP.NET的功能,像认证和会话(Session)引擎都是作为HttpModule来实现的.

　　虽然HttpModule看上去很像ISAPI过滤器,它们都检查每个通过ASP.NET应用的请求,但是它们只检查映射到单个特定的ASP.NET应用或虚拟目录的请求,也就是只能检查映射到ASP.NET的请求.这样你可以检查所有ASPX页面或者其他任何映射到ASP.NET的扩展名.你不能检查标准的.HTM或者图片文件,除非你显式的映射这些扩展名到ASP.NET ISAPI dll上,就像图1中展示的那样.一个常见的此类应用可能是使用模块来过滤特定目录中的JPG图像内容并在最上层通过GDI+来绘制’样品’字样.

　　实现一个HTTP模块是非常简单的:你必须实现之包含两个函数(Init()和Dispose())的IHttpModule接口.传进来的事件参数中包含指向HTTPApplication对象的引用,这给了你访问HttpContext对象的能力.在这些方法上你可以挂接到HttpApplication事件上.例如,如果你想挂接AuthenticateRequest事件到一个模块上,你只需像列表5中展示的那样做

　　列表5:基础的HTTP模块是非常容易实现的

public class BasicAuthCustomModule : IHttpModule
{
　public void Init(HttpApplication application)
　{
　　// *** Hook up any HttpApplication events
　　application.AuthenticateRequest += new EventHandler(this.OnAuthenticateRequest);
　}
　public void Dispose() { }

　public void OnAuthenticateRequest(object source, EventArgs eventArgs)
　{
　　HttpApplication app = (HttpApplication) source;
　　HttpContext Context = HttpContext.Current;
　　… do what you have to do… }
　}

　　记住你的模块访问了HttpContext对象,从这里可以访问到其他ASP.NET管道中固有的对象,如请求(Request)和响应(Response),这样你还可以接收用户输入的信息等等.但是记住有些东西可能是不能访问的,它们只有在处理链的后段才能被访问.

　　你可以在Init()方法中挂接多个事件,这样你可以在一个模块中实现多个不同的功能.然而,将不同的逻辑分到单独的类中可能会更清楚的将模块进行模块化(译注:这里的模块化和前面的模块没有什么关系)在很多情况下你实现的功能可能需要你挂接多个事件-例如一个日志过滤器可能在BeginRequest事件中记录请求开始时间,然后在EndRequest事件中将请求结束写入到日志中.

　　注意一个HttoModule和HttpApplication事件中的重点:Response.End()或HttpApplication.CompleteRequest()会在HttpApplication和Module的事件链中”抄近道”.看”注意Response.End()”来获得更多信息.

　　注意Response.End()

　　当创建HttpModule或者在Global.asax中实现事件钩子的时候,当你调用Response.End或 Appplication.CompleteRequest的时候要特别注意.这两个函数都结束当前请求并停止触发在HTTP管道中后续的事件,然后发生将控制返回到Web服务器中.当你在处理链的后面有诸如记录日志或对内容进行操作的行为时,因为他们没有被触发,有可能使你上当.例如,sample中logging的例子就会失败,因为如果调用Response.End()的话,EndRequest事件并不会被触发.

========================================================================================================================================================================

http://www.cnblogs.com/eycbest/archive/2010/03/30/1700240.html

public class HelloWorldModule : IHttpModule
{
    public HelloWorldModule()
    {
    }

    public String ModuleName
    {
        get { return "HelloWorldModule"; }
    }

    // In the Init function, register for HttpApplication
    // events by adding your handlers.
    public void Init(HttpApplication application)
    {
        application.BeginRequest +=
            (new EventHandler(this.Application_BeginRequest));
        application.EndRequest +=
            (new EventHandler(this.Application_EndRequest));
    }

    private void Application_BeginRequest(Object source,
         EventArgs e)
    {
    // Create HttpApplication and HttpContext objects to access
    // request and response properties.
        HttpApplication application = (HttpApplication)source;
        HttpContext context = application.Context;
        context.Response.Write("<h1><font color=red> HelloWorldModule: Beginning of Request</font></h1><hr>");
    }

    private void Application_EndRequest(Object source, EventArgs e)
    {
        HttpApplication application = (HttpApplication)source;
        HttpContext context = application.Context;
        context.Response.Write("<hr><h1><font color=red>HelloWorldModule: End of Request</font></h1>");
    }

    public void Dispose()
    {
    }
}

    <system.web>
   <httpModules>
    <add name="HelloWorldModule" type="HelloWorldModule"/>
   </httpModules>
    </system.web>

一 asp.net请求的处理过程
－－－－－－－－－－－－－－－－－－－
HttpModule 必须要掌握的东西
HttpHandler 必须要掌握的东西，非常有用
以上两个的实例
－－－－－－－－－－－－－－－－－－－－－
asp.net 事件模型机制

－－－－－－－－－－－－－－－－－－－－－－－
一
客户的请求页面由aspnet_isapi.dll这个动态连接库来处理，把请求的aspx文件发送给CLR进行编译执行，然后把Html流返回给浏览器
－－－－－－－－－－－－－－－－－－－－－－－－－－
二 页面事件
执行顺序
Page_Init：初始化值或连接
Page_Load:主要使用IsPostBack，该事件主要执行一系列得操作来首次创建asp.net页面或响应
由投递引起得客户端事件。在此事件之前，已还原页面和控件视图状态。
Page_DataBind:在页面级别上调用，也可在单个控件中调用。
DataBind_PreRender:数据绑定预呈现，恰好在保存视图状态和呈现控件之前激发此事件。
Page_Unload:此事件是执行最终清理工作的。
非确定事件
Page_Error：如果在页面处理过程中出现未处理的例外，则激发error事件。
Page_AbortTransaction:交易事件，事务处理中如果已终止交易，则激发此事件，购物车常用。
Page_CommitTransaction:如果已成功交易，则激发此事件。
--------------------------------------------------------
Global.asax中的事件（执行顺序）
Application_Start：应用程序启动时激发
Application_BeginRquest：http请求开始时激发
Application_AuthenticateRequest: 应用程序批准http请求时激发
Session_Start： 会话启动时激发
Application_EndRequest：Htttp请求结束时激发
Session_End：会话结束时激发
Application_End：应用程序结束时激发
Application_Error： 发生错误时激发
－－－－－－－－－－－－－－－－－－－－－－
ISAPI: 向web服务器插入某些组建，扩展功能，增强web服务器功能。
ISAPI: 扩展，win32的动态链接库，譬如aspnet_isapi.dll，可以把ISAPI扩展看作是一个普通的应用程序，它处理的目标是HTTP请求。
ISAPI: 过滤器，web服务器把请求传递给相关的过滤器，接下来过滤器可能修改请求，执行某些操作等等。
ASP.NET请求的处理过程：
基于管道模型，在模型中ASP.NET把http请求传递给管道中所有的模块。每个模块都接收HTTP请求，并有完全的控制权。一旦请求经过了所有的 HTTP模块，最终被HTTP处理程序处理。HTTP处理程序对请求进行一些处理，并且结果将再次经过模块管道中的HTTP模块。
－－－－－－－－－－－
httpmodule
ISAPI过滤器（筛选器）：IIS本身是不支持动态页面的，也就是说他仅仅支持静态HTML页面的内容，对于.asp .aspx .cgi .php等，IIS并不知道如果处理这些后缀标记，它就会把它当作文本，丝毫不做处理发送到客户端。为了解决这个问题，IIS有一种机制，叫做ISAPI 的过滤器。它是一个COM组件。
ASP.NET服务在注册到IIS的时候，会把每个扩展可以处理的文件扩展名注册到IIS里面（如*.ascx *.aspx等）。扩展启动后，就根据定义好的方式来处理IIS所不能处理的文件，然后把控制权跳转到专门处理代码的进程中，asp.net中是 aspnet_isapi.dll。让这个进程开始处理代码，生成标准的HTML代码，生成后把这些代码加入到原有的HTML中，最后把完整的HTML返 回给IIS，IIS再把内容发送到客户端。
－－－－－－－－－－－－－－－－
HttpModule
Http模块实现了过滤器(ISAPI filter)的功能，它是实现了System.Web.IHttpModule接口的.net组件。。这些组件通过在某些事件中注册自身，把自己插入到 ASP.NET请求处理管道。当这些事件发生的时候，ASP.NET调用对请求有兴趣的HTTP模块，这样该模块就能处理请求了。有时候需要过虑一下 http请求，注意它不是覆盖其他的包括系统自带的HttpModule，在Machine.config中配置完成。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
HttpHandler
它实现了ISAPI Extention的功能，它处理请求(Request)的信息和发送响应(Response)。HttpHandler功能的通过必须实现 IHttpHandler接口。HTTP处理程序是实现System.Web.IHttpHandler接口的.NET组件。任何实现了该接口的类都可以 用于处理输入的Http请求。它就是Http处理程序。

在以前的ASP时候，当请求一个*.asp页面文件的时候，这个HTTP请求首先会被一个名为inetinfo.exe进程所截获，这个进程实际上 就是www服务。截获之后它会将这个请求转交给asp.dll进程，这个进程就会解释这个asp页面，然后将解释后的数据流返回给客户端浏览器。其实 ASP.DLL是一个依附在IIS的ISAPI文件，它负责了对诸如ASP文件，ASA等文件的解释执行，
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

ASP.NET的HTTP请求处理方法
当客户端向web服务器请求一个*.aspx的页面文件时，同asp类似，这个http请求也会被inetinfo.exe进程截获（www服务），它判 断文件后缀之后，把这个请求转交给ASPNET_ISAPI.DLL而ASPNET_ISAPI.DLL则会通过一个Http PipeLine的管道，将这个http请求发送给ASPNET_WP.EXE进程，当这个HTTP请求进入ASPNET_WP.EXE进程之 后，asp.net framework就会通过HttpRuntime来处理这个Http请求，处理完毕后将结果返回给客户端。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
当一个http请求被送入到HttpRuntime之后，这个Http请求会继续被送入到一个被称之为HttpApplication Factory的一个容器当中，而这个容器会给出一个HttpApplication实例来处理传递进来的http请求，而后这个Http请求会依次进入 到如下几个容器中：
HttpModule --> HttpHandler Factory --> HttpHandler
当系统内部的HttpHandler的ProcessRequest方法处理完毕之后，整个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()
如果想在中途截获一个httpRequest并做些自己的处理，就应该在HttpRuntime运行时内部来做到这一点，确切的说时在 HttpModule这个容器中做到这个的。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
系统本身的HttpModule实现一个IHttpModule的接口，当然我们自己的类也能够实现IHttpModule接口，这就可以替代系统的 HttpModule对象了。
ASP.NET系统中默认的HttpModule：

DefaultAuthenticationModule 确保上下文中存在 Authentication 对象。无法继承此类。
FileAuthorizationModule 验证远程用户是否具有访问所请求文件的 NT 权限。无法继承此类。
FormsAuthenticationModule 启用 ASP.NET 应用程序以使用 Forms 身份验证。无法继承此类。
PassportAuthenticationModule 提供环绕 PassportAuthentication 服务的包装。无法继承此类。
SessionStateModule    为应用程序提供会话状态服务。
UrlAuthorizationModule    提供基于 URL 的授权服务以允许或拒绝对指定资源的访问。无法继承此类。
WindowsAuthenticationModule 启用 ASP.NET 应用程序以使用 Windows/IIS 身份验证。无法继承此类

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
这些系统默认的HttpModule是在文件machine.config中配置的，和我们开发时使用到的web.config的关系是：是在 ASP.NET FRAMEWORK启动处理一个Http Request的时候，它会依次加载machine.config和请求页面所在目录的web.config文件，如果在machine中配置了一个自己 的HttpModule，你仍然可以在所在页面的web.config文件中remove掉这个映射关系。 

 从网上查到是资料，感觉很重要，特此留下！

 

 

 

==========================================================================================================================================================

http://blog.csdn.net/chengfong/article/details/4088530

http://blog.csdn.net/chengfong/article/details/4088530

HttpModule概述

暂时先不考虑我们自己实现Http Module的情况。在.Net中，Http Module 是实现了IHttpModule接口的程序集。IHttpModule 接口本身并没有什么好大写特写的，由它的名字可以看出，它不过是一个普普通通的接口而已。实际上，我们关心的是实现了这些接口的类，如果我们也编写代码实现了这个接口，那么有什么用途。一般来说，我们可以将Asp.Net中的事件分成三个级别，最顶层是 应用程序级事件、其次是页面级事件、最下面是控件级事件，事件的触发分别与 应用程序周期、页面周期、控件周期紧密相关。而 Http Module 的作用是与应用程序事件 密切相关的。

我们通过Http Module在Http请求管道(Pipeline)中注册期望对应用程序事件做出反应的方法，在相应的事件触发的时候(比如说BeginRequest事件，它在应用程序收到一个Http请求并即将对其进行处理时触发)，便会调用Http Module注册了的方法，实际的工作在这些方法中执行。.Net 本身已经有很多的Http Module，其中包括 表单验证Module(FormsAuthenticationModule)， Session 状态Module(SessionStateModule)，输出缓存Module (OutputCacheModule)等。

注册 Http Module

在注册我们自己编写的 Http Module 之前，先来看看Asp.Net中已经有的HttpModule。与 Http Handler类似，我们需要打开机器上C:/WINDOWS/Microsoft.NET/Framework/ v2.0.50727/CONFIG 目录下的 web.config 文件。找到 <httpModules/> 结点，应该可以看到下面的内容：

<httpModules>
    <add name="OutputCache" type="System.Web.Caching.OutputCacheModule" />
    <add name="Session" type="System.Web.SessionState.SessionStateModule" />
    <add name="WindowsAuthentication" type="System.Web.Security.WindowsAuthenticationModule" />
    <add name="FormsAuthentication" type="System.Web.Security.FormsAuthenticationModule" />
    <add name="PassportAuthentication" type="System.Web.Security.PassportAuthenticationModule" />
    <add name="RoleManager" type="System.Web.Security.RoleManagerModule" />
    <add name="UrlAuthorization" type="System.Web.Security.UrlAuthorizationModule" />
... 略
</httpModules>

我们先从结点上看，type属性与上一节所说的http handler结点的type属性类似，都代表了相应的程序集。但是，与http handler 不同，module只提供了一个name属性，没有诸如 path这样指定某一特定(或者用通配符 * 代表某一种类)文件的处理程序。这是与Module的特点相关的，我们知道 module 是响应应用程序周期中触发的事件，对于所有提交到aspnet_isapi.dll的请求都一样，即便请求只是像类似http://www.tracefact.net/images/logo.gif 这样获取一张图片而已(对ISAPI进行过设置以后，默认aspnet_isapi.dll不接手图片文件)。

与Http handler类似，在这册我们自己的http module 时，假设类名为ModuleDemo，位于myNameSpace命名空间下，程序集名称为myDll，我们只需将myDll.dll拷贝到Bin目录下，并在站点的 web.config 文件 system.web 结点下创建 httpModules 结点：

<system.web>
    <httpModules>
       <add name="CustomModuleName" type="myNameSpace.ModuleDemo, myDll"/>
    </httpModules>
</system.web>

type属性由分号“,”分为两部分，前面是命名空间及类名，也就是类型名；后面是程序集名。如果我们将代码创建在App_Code目录中，则不需要再指定程序集名。

name属性由我们自己命名，不一定与类名相同，此处我将它命名为“CustomModuleName”。我们可以通过应用程序(HttpApplication)的Modules属性获取HttpModuleCollection集合，然后通过name属性，进一步获取HttpModule对象。

通过name属性，我们还可以在global.asax中文件中编写自定义HttpModule暴露出的事件的处理程序，它采用的格式是：void ModuleName_EventName(object sender, EventArgs e)。我们将在后面做更详细介绍。

Asp.Net 内置的 Http Modules

下面这张表格列出了C:/WINDOWS/Microsoft.NET/Framework/ v2.0.50727/CONFIG下的Web.Config中的 Asp.Net 内置的Http Modules 及其主要作用。

名称	类型	功能
OutputCache	System.Web.Caching.OutputCacheModule	页面级输出缓存
Session	System.Web.SessionState.SessionStateModule	Session状态管理
WindowsAuthentication	System.Web.Security.WindowsAuthenticationModule	用集成Windows身份验证进行客户端验证
FormsAuthentication	System.Web.Security.FormsAuthenticationModule	用基于Cookie的窗体身份验证进行客户端身份验证
PassportAuthentication	System.Web.Security.PassportAuthenticationModule	用MS护照进行客户身份验证
RoleManager	System.Web.Security.RoleManagerModule	管理当前用户角色
UrlAuthorization	System.Web.Security.UrlAuthorizationModule	判断用户是否被授权访问某一URL
FileAuthorization	System.Web.Security.FileAuthorizationModule	判断用户是否被授权访问某一资源
AnonymousIdentification	System.Web.Security.AnonymousIdentificationModule	管理Asp.Net应用程序中的匿名访问
Profile	System.Web.Profile.ProfileModule	管理用户档案文件的创立 及相关事件
ErrorHandlerModule	System.Web.Mobile.ErrorHandlerModule	捕捉异常，格式化错误提示字符，传递给客户端程序

我们将在后面用编程的方式来查看它。

IHttpModule接口

看了这么多理论知识，本节将开始动手写点程序，实现自己的Http Module。我们首先需要看下IHttpModule 接口，它包括下面两个方法：

public void Init(HttpApplication context);
public void Dispose();

Init()：这个方法接受一个HttpApplication对象，HttpApplication代表了当前的应用程序，我们需要在这个方法内注册 HttpApplication对象暴露给客户端的事件。可见，这个方法仅仅是用来对事件进行注册，而实际的事件处理程序，需要我们另外写方法。

整个过程很好理解：

1. 当站点第一个资源被访问的时候，Asp.Net会创建HttpApplication类的实例，它代表着站点应用程序，同时会创建所有在Web.Config中注册过的Module实例。
2. 在创建Module实例的时候会调用Module的Init()方法。
3. 在Init()方法内，对想要作出响应的HttpApplication暴露出的事件进行注册。(仅仅进行方法的简单注册，实际的方法需要另写)。
4. HttpApplication在其应用程序周期中触发各类事件。
5. 触发事件的时候调用Module在其Init()方法中注册过的方法。

NOTE：如果你不了解事件注册等相关内容，请参阅 C#中的委托与事件 一文。

Dispose()：它可以在进行垃圾回收之前进行一些清理工作。

综上所述：实现一个 IHttpModule 的模板一般是这样的：

public class ModuleDemo:IHttpModule
{
    public void Init(HttpApplication context) {
       // 注册HttpApplication应用程序 BeginRequest 事件
       // 也可以是其他任何HttpApplication暴露出的事件
       context.BeginRequest += new EventHandler(context_BeginRequest);
    }

    void context_BeginRequest(object sender, EventArgs e) {
       HttpApplication application = (HttpApplication)sender;
       HttpContext context = application.Context;
       // 做些实际的工作，HttpContext对象都获得了，剩下的基本可以自由发挥了
    }

    public void Dispose() {
    }
}

通过Http Module向Http请求输出流中写入文字

本例中，我们仅用BeginRequest事件和 EndRequest 事件对 Http Module 的使用作以说明。我们通过这个范例，了解 Http Module 基本的使用方法。

首先，请创建一个新的站点，在App_Code目录中添加类文件： ModuleDemo.cs：

public class ModuleDemo:IHttpModule
{
    // Init方法仅用于给期望的事件注册方法
    public void Init(HttpApplication context) {
       context.BeginRequest += new EventHandler(context_BeginRequest);
       context.EndRequest += new EventHandler(context_EndRequest);
    }

    // 处理BeginRequest 事件的实际代码
    void context_BeginRequest(object sender, EventArgs e) {
       HttpApplication application = (HttpApplication)sender;
       HttpContext context = application.Context;
       context.Response.Write("<h1 style='color:#00f'>来自HttpModule 的处理，请求到达</h1><hr>");
    }

    // 处理EndRequest 事件的实际代码
    void context_EndRequest(object sender, EventArgs e) {
       HttpApplication application = (HttpApplication)sender;
       HttpContext context = application.Context;
       context.Response.Write("<hr><h1 style='color:#f00'>来自HttpModule的处理，请求结束</h1>");
    }
      
    public void Dispose() {
    }
}

上面的代码很简单，它注册了 HttpApplication实例的 BeginRequest 事件 和 EndRequest事件，事件处理方法的作用仅仅是在http请求开始和结束的时候，给http请求的输入流中分别写入不同的内容。

接下来在 Web.config 的 System.web 结点中写入以下内容：

<system.web>
    <httpModules>
       <add name="MyModule" type="ModuleDemo" />
    </httpModules>
</system.web>

然后，打开建立站点时自动创建的 Default.aspx文件，在里面打几个字，为了做区分，我输入的是：位于.aspx页面上的文字。然后，我们在浏览器中打开它，应该会看到像这样：

然后我们再新建一个 Default2.aspx，在浏览器中浏览，可以看到，两个页面的效果相同。这说明对于不同的两个文件，http Module都起了作用，可见它确实是位于应用程序级，而非页面级。

现在，我们再打开站点中的一张图片文件，发现显示出的是一个红叉叉，为什呢？因为Http Module 针对是http 请求，而不是某个或某一类文件，所以当请求一张图片的时候，我们编写的http Module依然会起作用，将文字插入到二进制图片中，破坏了文件格式，自然只能显示红叉叉了。

NOTE：如果你发现你的图片显示正常，请不要惊讶，事情是这样的：回想一下第一节我们讨论到的，对于图片文件，由IIS直接处理，并不会交由aspnet_isapi.dll，所以，Module无法捕获对于图片类型文件的请求。解决方法就是在IIS中进行设置一下。
    这里需要提请注意的是：如果你使用Vs2005自带的Local Server，那么你无需对IIS进行设置，所有的不论图片还是任何文件类型，都会交由aspnet_isapi.dll处理。

遍历Http Module集合

现在，我们通过遍历 HttpModuleCollection 集合来查看注册给应用程序的所有 Http Module 的名称。

新建一个文件 RegisteredModules.aspx，在代码后置文件中添加如下方法：

private string ShowModules() {
    HttpApplication app = Context.ApplicationInstance; //获取当前上下文的HttpApplication环境
    HttpModuleCollection moduleCollection = app.Modules; //获取所有Module集合

    // 获取所有的 Module 名称
    string[] moduleNames = moduleCollection.AllKeys;

    System.Text.StringBuilder results = new System.Text.StringBuilder();    //遍历结果集

    foreach (string name in moduleNames) {
       // 获得Module名称
       results.Append("<b style='color:#800800'>名称：" + name + "</b><br />");
        // 获得Module类型
       results.Append("类型：" + moduleCollection[name].ToString() + "<br />");
    }

    return results.ToString();
}

然后在Page_Load方法中输出一下：

protected void Page_Load(object sender, EventArgs e)
{
    Response.Write(ShowModules());
}

我们应该可以看到下面这样的画面：

与之前列出的那张表格比较一下，可以看出是几乎完全一致的(多了一个DefaultAuthentication)。另外注意上图的倒数第四行，那不是我们自己定义的Module么？name为MyModule，类型为ModuleDemo。

Global.asax文件与 Http Module

早在asp时代，大家就知道这个文件了。它主要用于放置对于 应用程序事件或者 Session事件的响应程序。大家熟悉的有Application_Start、Application_End、Session_Start、Session_End 等。

在asp.net中，Glabal不仅可以注册应用程序和Session事件，还可以注册Http Module暴露出的事件；不仅可以注册系统Module的事件，也可以注册我们自己义的Module暴露出的事件。在具体介绍之前，这里需要首先注意两点：

1. 在每处理一个Http请求时，应用程序事件都会触发一遍，但是Application_Start和 Application_End 例外，它仅在第一个资源文件被访问时被触发。
2. Http Module无法注册和响应Session事件，对于Session_Start 和 Session_End，只能通过Glabal.asax来处理。

好了，我们现在修改之前 ModuleDemo 范例程序，给它像下面这样给它添加一个事件(为了使程序简洁一些，我做了简化)：

public class ModuleDemo : IHttpModule {

    // 声明一个事件
    public event EventHandler ExposedEvent;

    // Init方法仅用于给期望的事件注册方法
    public void Init(HttpApplication context) {
       context.BeginRequest += new EventHandler(context_BeginRequest);
    }

    // 处理BeginRequest 事件的实际代码
    void context_BeginRequest(object sender, EventArgs e) {
       HttpApplication application = (HttpApplication)sender;
       HttpContext context = application.Context;
       context.Response.Write("<h3 style='color:#00f'>来自HttpModule的处理，请求到达</h3><hr>");
      
       OnExposedEvent(new EventArgs()); // 调用方法
    }

    protected override void OnExposedEvent(EventArgs e) {
       if (ExposedEvent != null) // 如果Global中有注册
           ExposedEvent(this, e);   // 调用注册了的方法
    }
   
    public void Dispose() {
    }
}

接下来，我们在站点中创建一个 Global.asax 文件，在里面添加如下代码，注意到格式是：void 模块名_事件名(object sender, EventArgs e)。

void MyModule_ExposedEvent(object sender, EventArgs e)
{
     Response.Write("<h3 style='color:#800800'>来自 Global.asax 的文字</h2>");
}

现在，我们打开之前的页面，应该可以见到这样，可见，我们成功的将 Glabal.asax文件与我们自己定义的Http Module所暴露出的事件 ExposedEvent 联系到了一起：

总结

本文简单地介绍了什么是Http Module。我们首先了解了Http Module的作用，然后查看了Asp.Net 内置的Module，接着我们介绍了IHttpModule接口，并通过了一个简单的范例实现了此接口，最后我们讨论了 Http Module与 Global.asax 文件的联系。

本文仅仅是对IHttpModule作以简单介绍，对其更多的实际应用，会在后续文章中补充。

希望这篇文章能给你带来帮助！

 

 

 

 

IHttpHandler 概述

可能和我一样，很多Asp.Net开发人员都有过Asp的背景，以至于我们在开发程序的时候，通常都是在“页面级”上思考，也就是说我们现在正在做的这个页面应该有什么样的功能，是进行一个问卷调查还是一个数据库查询等等。而很少在“请求级”思考，考虑有没有办法来通过编码的方式来操控一个Http请求。

实际上，Framework提供了一系列的接口和类，允许你对于Http请求进行编程，而实现这一操作的一个主要的接口，就是 IHttpHandler(另一个是IHttpModule)。

应该还记得第一节中我们提到过 ISAPI，它根据文件名后缀把不同的请求转交给不同的处理程序。但是仔细看看就会发现：几乎一大半的文件都交给 aspnet_isapi.dll 去处理了。很明显，aspnet_isapi.dll 不可能对每种文件采用同一种方式处理，那么 aspnet_isapi.dll 是如何更进一步处理不同的文件，交由谁去处理呢？为了搞清楚这个问题，我们需要打开机器上C:/WINDOWS/Microsoft.NET/Framework/v2.0.50727/CONFIG/ 目录下的web.config 文件。

NOTE：我查阅了很多资料，都说是在 machine.config 中，但实际上 v2.0.50727 下的machine.config中httpHandlers结点是这样的：<httpHandlers />，并没有给出详细的处理程序，在Web.config中才能看到。而v1.1.4322 下的machine.config中却有。

找到httpHandlers结点，应该可以看到如下这样的代码(做了省略)：

<httpHandlers>
... ... //略
<add path="*.axd" verb="*" type="System.Web.HttpNotFoundHandler" validate="True" /><add path="*.aspx" verb="*" type="System.Web.UI.PageHandlerFactory" validate="True" />
   <add path="*.ashx" verb="*" type="System.Web.UI.SimpleHandlerFactory" validate="True" />
   <add path="*.asax" verb="*" type="System.Web.HttpForbiddenHandler" validate="True" />
<add path="*.ascx" verb="*" type="System.Web.HttpForbiddenHandler" validate="True" />
   <add path="*.config" verb="*" type="System.Web.HttpForbiddenHandler" validate="True" />
   <add path="*.cs" verb="*" type="System.Web.HttpForbiddenHandler" validate="True" />
   <add path="*" verb="GET,HEAD,POST" type="System.Web.DefaultHttpHandler" validate="True" />
   ... ... //略
</httpHandlers>

可以看到，在<httpHandlers>结点中将不同的文件类型映射给不同的Handler去处理，对于.aspx来说，是由System.Web.UI.PageHandlerFactory来处理。而对于.cs来说，是由System.Web.HttpForbiddenHandler 处理，从ForbiddenHandler名字中出现的Forbidden (翻译过来是“禁止”)可以看出，这个Handler可以避免我们的源码被看到。

NOTE：System.Web.UI.PageHandlerFactory 是一个IHttpHandlerFactory，而不是一个单一的HttpHandler，IHttpHandlerFactory用来做什么后面会说明。

上面列出的是.Net Framework在处理Http请求时的所采用的默认Handler。而如果我们要用编程的方式来操控一个Http请求，我们就需要实现IHttpHandler接口，来定制我们自己的需求。

IHttpHandler的定义是这样的：

public interface IHttpHandler{
    void ProcessRequest(HttpContext context);
    bool IsReusable { get; }
}

由上面可以看出IHttpHandler要求实现一个方法和一个属性。其中 ProcessRequest，从名字(处理请求)看就知道这里应该放置我们处理请求的主要代码。

IsReusable属性，MSDN上是这样解释的：获取一个值，该值指示其他请求是否可以使用 IHttpHandler 实例。也就是说后继的Http请求是不是可以继续使用实现了该接口的类的实例，一般来说，我把它设置成true。

那么实现此接口的类形式应该是这样的：

public class CustomHandler : IHttpHandler{
    public void ProcessRequest(HttpContext context)  {
       // 处理请求的代码
    }
    public bool IsReusable {
       get { return true; }
    }
}

而为了能使用这个自定义的HttpHandler，我们需要在应用程序目录下的Web.config中注册它。

 <system.web>
    <httpHandlers>
      <add path="*.jpg" verb="*" type="MyNameSpace.MyClass, MyDllName" />
    </httpHandlers>
 </system.web>

应该发现这与之前在C:/WINDOWS/Microsoft.NET/Framework/v2.0.50727/CONFIG/目录下web.config中看到的几乎完全一样。这里，path指的是请求的文件名称，可以使用通配符扩大范围，也可以明确指定这个handler仅用于处理某个特定的文件(比如说：filename.aspx)的请求。verb指的是请求此文件的方式，可以是post或get，用*代表所有访问方式。type属性由“,”分隔成两部分，第一部分是实现了接口的类名，第二部分是位于Bin目录下的编译过的程序集名称。

NOTE：如果你新建一个项目，并且在项目下创建HandlerTest.cs，然后让站点引用该项目，那么在生成解决方案的时候会自动将编译好的.dll文件添到Bin目录中。
    NOTE：MyDll只写程序集名，不要加后面的.dll。

使用HttpHandler实现图片防盗链

有了之前这么多的准备知识，实现现在的目标就容易得多了：

NOTE：这个例子，以及下面的一个例子均来自于《Maximizing ASP.NET Real World, Object-Oriented Development》一书：

Step.1：创建文件 CustomHandler.cs，代码如下：

using System;
using System.Web;

namespace CustomHandler{
    public class JpgHandler : IHttpHandler{
       public void ProcessRequest(HttpContext context){
           // 获取文件服务器端物理路径
           string FileName = context.Server.MapPath(context.Request.FilePath);
           // 如果UrlReferrer为空，则显示一张默认的禁止盗链的图片
           if (context.Request.UrlReferrer.Host == null){
              context.Response.ContentType = "image/JPEG";
              context.Response.WriteFile("/error.jpg");
           }else{
              // 如果 UrlReferrer中不包含自己站点主机域名，则显示一张默认的禁止盗链的图片
             if (context.Request.UrlReferrer.Host.IndexOf("yourdomain.com") > 0){
                  context.Response.ContentType = "image/JPEG";
                  context.Response.WriteFile(FileName);
              }else{
                  context.Response.ContentType = "image/JPEG";
                  context.Response.WriteFile("/error.jpg");
              }
           }
       }

       public bool IsReusable{
           get{ return true; }
       }
    }
}

Step.2 编译这个文件

csc /t:library /r:System.Web.dll CustomHandler.cs

Step.3 将编译好的 CustomHandler.dll 拷贝到站点的 Bin 目录下。

Step.4 在Web.Config 中注册这个Handler。

<system.web>
    <httpHandlers>
      <add path="*.jpg" verb="*" type="CustomHandler.JpgHandler, CustomHandler" />
    </httpHandlers>
 </system.web>

OK，诸位可以按步骤自行测试一下，这里就不赘述了。

通过IhttpHandler实现图片验证码

也可以在一个.ashx文件中实现IHttpHandler，而不是采用这种提前编译的方式。

Step.1 打开Vs2005，“添加新项”，“一般处理程序”。新建文件后，VS会自动在文件中添加如下的代码：

<%@ WebHandler Language="C#" Class="Handler" %>

using System;
using System.Web;

public class Handler : IHttpHandler {
    public void ProcessRequest (HttpContext context) {
        context.Response.ContentType = "text/plain";
        context.Response.Write("Hello World");
    }
 
    public bool IsReusable {
        get {
            return false;
        }
    }
}

Step.2 将代码改写成如下所示：

<%@ WebHandler Language="C#" Class="Handler" %>

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Text;
using System.Web;
using System.Web.SessionState;

public class Handler : IHttpHandler, IRequiresSessionState {

    public void ProcessRequest(HttpContext context) {
       context.Response.ContentType = "image/gif";
       //建立Bitmap对象，绘图
       Bitmap basemap = new Bitmap(200, 60);
       Graphics graph = Graphics.FromImage(basemap);
       graph.FillRectangle(new SolidBrush(Color.White), 0, 0, 200, 60);
       Font font = new Font(FontFamily.GenericSerif, 48, FontStyle.Bold, GraphicsUnit.Pixel);
       Random r = new Random();
       string letters = "ABCDEFGHIJKLMNPQRSTUVWXYZ";
       string letter;
       StringBuilder s = new StringBuilder();
      
       //添加随机的五个字母
       for (int x = 0; x < 5; x++) {
           letter = letters.Substring(r.Next(0, letters.Length - 1), 1);
           s.Append(letter);
           graph.DrawString(letter, font, new SolidBrush(Color.Black), x * 38, r.Next(0, 15));
       }
      
       //混淆背景
       Pen linePen = new Pen(new SolidBrush(Color.Black), 2);
       for (int x = 0; x < 6; x++)
           graph.DrawLine(linePen, new Point(r.Next(0, 199), r.Next(0, 59)), new Point(r.Next(0, 199), r.Next(0, 59)));
             
       //将图片保存到输出流中      
       basemap.Save(context.Response.OutputStream, ImageFormat.Gif);
       context.Session["CheckCode"] = s.ToString();   //如果没有实现IRequiresSessionState，则这里会出错，也无法生成图片
       context.Response.End();     
    }

    public bool IsReusable {
       get { return true; }
    }
}

需要特别注意的是，Handler类不仅需要实现 IHttpHandler接口(这个显然)，为了在这个Handler类中使用SessionState，还需要实现IRequiresSessionState接口，对于这个接口，MSDN的解释是这样的：Specifies that the target HTTP handler requires read and write access to session-state values. This is a marker interface and has no methods.(翻译过来是：指定当前Http Handler需要对SessionState值的读写访问权。这是一个标记接口，没有任何方法)。

而实际上，IRequiresSessionState的接口定义是这样的：

public interface IRequiresSessionState{}

可见，这个接口没有任何需要实现的方法或属性，大家只要记得：如果想在HttpHandler中使用SessionState，必须实现这个接口，实际上也就是在类的标头将这个接口加进去。

Step.3 新建一个ImageCode.aspx页面，在HTML代码中写下：

<img src="Handler.ashx" alt="图片验证码" />

OK，在浏览器中打开ImageCode.aspx，应该可以看到如下所示：

利用HttpHandler创建自定义后缀Rss源

RSS如今已经可以说是随处可见，而RSS的实现方式，通常是在一个.aspx的CodeBehind文件中写一个XML文件，然后加载到Response的OutputStream中， Rss源通常是Rss.aspx这种形式的。通过第一章学到的ISAPI的知识，再结合本章学到的关于HttpHandler的知识，很容易想到：我们可以自定一个以 .rss 作为后缀名的文件来实现 Rss 源，比如说Article.rss。现在我们就一步步来实现它：

NOTE：关于RSS的更多内容，可以参阅我编译的 在Web站点中创建和使用RSS源。本文不再解释Rss是什么，如何创建Rss源，为了文章的独立性，仅给出创建过程。

Step.1 创建范例数据库

Create Table RssSample
(
    SampleId      Int Identity(1,1)    Not Null,
    Title         Varchar(100)          Not Null Constraint uq_Title Unique,
    Author        Varchar(50)              Not Null,
    PubDate       DateTime              Not Null Default GetDate(),
    [Description] Varchar(500)          Not Null,
    Link          Varchar(150)          Not Null

    Constraint pk_RssSample Primary Key(SampleId)
)
-- 插入范例数据
Insert Into RssSample(Title, Author, [Description], Link)
Values('标题1', '作者1', '文章摘要1', 'http://127.0.0.1/#' )

-- 省略 ....

Step.2 建立站点，在App_Code目录下建立RssFeedsLib.cs文件。

using System;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Web;
using System.Xml;
using System.Text;

namespace RssFeadsLib {
    public class RssGenerator {
       public static string GetRSS() {
           MemoryStream ms = new MemoryStream();
           XmlTextWriter writer = new XmlTextWriter(ms, null);
           SqlConnection conn = new SqlConnection("Data Source=.;Initial Catalog=Sample;User ID=sa;Password=sa");       //修改这里成你的数据库连接
           SqlCommand cmd = new SqlCommand("select * from RssSample order by pubdate desc", conn);

           conn.Open();
           SqlDataReader reader = cmd.ExecuteReader();
           writer.WriteStartElement("rss");
           writer.WriteAttributeString("version", "2.0");
           writer.WriteStartElement("channel");
           // Channel 下的结点静态写入
           writer.WriteElementString("title", "TraceFact.Net 技术文章");
           writer.WriteElementString("link", "http://www.tracefact.net");
           writer.WriteElementString("description", "Dedicated to asp.net...");
           writer.WriteElementString("copyright", "Copyright (C) 2007");
           writer.WriteElementString("generator", "My RSS Generator");
           // Item 结点从数据库读取
           while (reader.Read()) {
              writer.WriteStartElement("item");
              writer.WriteElementString("author", reader.GetString(reader.GetOrdinal("Author")));
              writer.WriteElementString("title",             reader.GetString(reader.GetOrdinal("title")));
              writer.WriteElementString("link", reader.GetString(reader.GetOrdinal("Link")));
              writer.WriteElementString("description", reader.GetString(reader.GetOrdinal("Description")));
              writer.WriteElementString("pubDate", reader.GetDateTime(reader.GetOrdinal("PubDate")).ToString(@"ddd, dd MMM yyyy 12:00:00 tt "));
              writer.WriteEndElement();
           }

           writer.WriteEndElement();
           writer.WriteEndElement();
           reader.Close();
           conn.Close();

           writer.BaseStream.Flush();
           writer.Flush();
           ms.Flush();

           // 将流转换成String并返回
           byte[] data = new byte[ms.Length];
           ms.Seek(0, SeekOrigin.Begin);
           ms.Read(data, 0, data.Length);
           ms.Close();
           return UTF8Encoding.UTF8.GetString(data);
       }
    }
}

Step.3 创建可以处理 .rss 后缀名的 RssHandler

我们在这个 RssFeedsLib命名空间下，再添加一个类，这个类用于处理对 .rss 后缀名文件的Http请求。

public class RSSHandler:IHttpHandler{
    public bool IsReusable
    {
       get {return false;}
    }

    public void ProcessRequest(HttpContext context){
       context.Response.ContentType = "text/xml";
       string str = RssGenerator.GetRSS();
       context.Response.Write(str);
    }
}

Step.4 在Web.config中进行配置

<httpHandlers>
    <add path="*.rss" type="RssFeadsLib.RSSHandler" verb="GET" />
</httpHandlers>

 

NOTE：因为这个类和命名空间位于App_Code中，这里就不需要再手动编译RssFeadsLib.cs然后将编译好的.dll应用程序集放到Bin目录中了。至于为什么可以这样，将会在 《Asp.Net 构架与安全机制 Part.5 – 页面生存周期与编译模型》中解释。

Step.5 在IIS 对ISAPI进行设置。

应该还记得在Part.1中如何在IIS中设置ISAPI来进行文件与处理程序映射：

1. 打开IIS，选择本范例所用的站点，右键，选择“属性”。
2. 选择“主目录”选项卡，点击“配置...”按钮。
3. 点击“添加”，设置“可执行文件”为“C:/WINDOWS/Microsoft.NET/Framework/v2.0.50727/aspnet_isapi.dll”，设置“扩展名”为“.rss”，点“确定”。
4. 注意，不要勾选“检查文件是否存在”复选框，这样不用创建文件，只要在地址栏输入任意以.rss后缀结尾的文件名，均会交由上面创建的Handler去处理，而不管这个文件是否存在，也不管请求的是Article.rss还是Sample.rss。

进行了这些设置以后，现在IIS就知道如何去处理对.rss后缀名文件的请求了。

Step.6 测试范例

这个时候，随便打开一个页面，比如空白的Default.aspx，然后我们在地址栏将文件改为：Article.rss(改成abc.rss也是一样)，敲回车，应该可以看到如下的画面。

IHttpHandlerFactory 概述

现在假设我们有这样的需求，我们不仅想要处理 .rss 后缀名，还想要能够处理 .atom后缀名，假设处理atom的类命名为AtomHandler，那么我们的Web.config该如何设置呢？我想应该是这样的：

<httpHandlers>
<add path="*.rss" type="RssFeadsLib.RSSHandler" verb="GET" />
<add path="*.atom" type="RssFeadsLib.AtomHandler" verb="GET" />
</httpHandlers>

如果我们有很多个HttpHandler分别映射不同后缀名的请求，这样我们的Web.config会变得很冗长，或者，我们只有在程序运行时才能确切地知道使用哪个Handler，这个时候，可以考虑实现 IHttpHandlerFactory来完成这一过程。

IHttpHandlerFactory的定义是这样的：

public interface IHttpHandlerFactory{
    IHttpHandler GetHandler(HttpContext context, string requestType, string url, string pathTranslated);
    void ReleaseHandler(IHttpHandler handler);
}

可见，需要实现两个方法，分别是 GetHandler() 和 ReleaseHandler()。

• GetHandler()，返回实现了IHttpHandler接口的类的实例。
• ReleaseHandler()，使得Factory可以重复使用一个已经存在的Handler实例。

对于上面 .atom 和 .rss 的问题，我们可以这样来实现 IHttpHandlerFactory接口：

class HandlerFactory:IHttpHandlerFactory{
    public IHttpHandler GetHandler(HttpContext context, string requestType, string url, string pathTranslated){
       string path = context.Request.PhysicalPath;
       if (Path.GetExtension(path) == ".rss"){
           return new RSSHandler();
       }

       if (Path.GetExtension(path) == ".atom"){
           return new ATOMHandler();
       }
       return null;
    }

    public void ReleaseHandler(IHttpHandler handler){
    }
}

这时，在Web.Config 中<system.web>节点下进行如下设置即可：

<httpHandlers>
<add path="*.rss,*.atom" type=" RssFeadsLib.HandlerFactory" verb="GET" />
</httpHandlers>

但是，这不能简化IIS中ISAPI的设置，还是需要手动去对.rss和.atom分别设置。

总结

在本文中，我们首先讨论了aspnet_isapi.dll 如何将对不同后缀名文件的请求分发给相应的处理程序，如何查看Framework默认的处理程序Handler。

然后，我们通过三个实例，图片防盗链、图片验证码、处理自定义后缀名请求，详细讲解了IHttpHandler的实现方法和使用过程。

最后，我向大家概要地介绍了IHttpHandlerFactory接口