1.请求的处理参数—上下文对象HttpContext

　　1) 针对每一次请求，ASP.NET将创建一个处理这次请求所使用的HttpContext对象实例，这个对象实例将用来在ASP.NET服务器的处理过程中传递所需要的参数，在请求到达ASP.NET服务器之后，这个对象将被创建出来，再一次请求处理之后，这个对象将被丢弃掉，由于在大多数的处理环节都需要用到这个对象，因此，HttpContext类中还提供了一个名为Current的静态属性，以便于在处理过程中，不需要通过方法的参数而直接取得当前的上下文对象，当然，在没有请求的情况下，通过这个属性获得的结果将是null。

　　2) HttpContext中的常见属性：http://msdn.microsoft.com/zh-cn/library/system.web.httpcontext(v=vs.110).aspx

2.应用程序对象 HttpApplication

　　1) 当HttpContext对象创建之后，HttpRuntime将随后创建一个用于处理请求的对象，这个对象的类型就是HttpApplication。

　　2) 处理管道：所谓的处理管道，就是处理复杂问题的时候，将处理的过程分解为多个处理步骤，我们将这种经过多个步骤的处理方式称为处理管道。对于管道来说，它往往需要暴漏出大量的时间，通过这些事件，提供程序员的扩展机制。

　　3) 对于有很多事件的类来说，大量定义事件意味着创建对象的时候需要付出创建时间的成本，因为在.NET中，所谓的事件就是一个受限制的委托成员，定义多个事件，以为找在创建对象的时候需要更多的存储空间，对于这样的问题：在System.ComponentModel.Component类中，提供了处理多个事件的基础：Events属性，它的类型为：System.ComponentModel.EventHandlerList，这是一个线性的字典，当需要事件的时候，就通过Key将事件保存到集合中，如果没有对应的事件，就不会创建事件的成本了这样，通过EventHandlerList可以在一个集合中管理多个事件对象，节省了事件对象占用的空间，他的主要属性：http://msdn.microsoft.com/zh-cn/library/system.componentmodel.eventhandlerlist.aspx。

　　4)下面代码演示了如何在类中定义多个事件，并创建处理管道，代码如下：

  1 public class ProcessPipleline : Component
  2 {
  3     private static readonly object StartEvent = new object();
  4     private static readonly object PreProcessEvent = new object();
  5     private static readonly object PostProcessEvent = new object();
  6     private static readonly object EndEvent = new object();
  8     public event EventHandler StartProcess
  9     {
 10         add { this.Events.AddHandler(StartEvent, value); }
 11         remove { this.Events.RemoveHandler(StartEvent, value); }
 12     }
 14     public event EventHandler PreProcess
 15     {
 16         add { this.Events.AddHandler(PreProcessEvent, value); }
 17         remove { this.Events.RemoveHandler(PreProcessEvent, value); }
 18     }
 20     public event EventHandler PostProcess
 21     {
 22         add { this.Events.AddHandler(PostProcessEvent, value); }
 23         remove { this.Events.RemoveHandler(PostProcessEvent, value); }
 24     }
 26     public event EventHandler EndProcess
 27     {
 28         add { this.Events.AddHandler(EndEvent, value); }
 29         remove { this.Events.RemoveHandler(EndEvent, value); }
 30     }
 32     protected void OnStartProcess(EventArgs e)
 33     {
 34         if (this.Events[StartEvent] != null)
 35         {
 36             (this.Events[StartEvent] as EventHandler)(this, e);
 37         }
 38     }
 40     protected void OnPreProcess(EventArgs e)
 41     {
 42         if (this.Events[PreProcessEvent] != null)
 43         {
 44             (this.Events[PreProcessEvent] as EventHandler)(this, e);
 45         }
 46     }
 48     protected void OnPostProcess(EventArgs e)
 49     {
 50         if (this.Events[PostProcessEvent] != null)
 51         {
 52             (this.Events[PostProcessEvent] as EventHandler)(this, e);
 53         }
 54     }
 56     protected void OnEndProcess(EventArgs e)
 57     {
 58         if (this.Events[EndEvent] != null)
 59         {
 60             (this.Events[EndEvent] as EventHandler)(this, e);
 61         }
 62     }
 64     public void Process()
 65     {
 66         Console.WriteLine("开始处理");
 67         this.OnStartProcess(EventArgs.Empty);
 68         Console.WriteLine("准备处理");
 69         this.OnPreProcess(EventArgs.Empty);
 70         Console.WriteLine("正在处理中");
 71         Console.WriteLine("处理完成");
 72         this.OnPostProcess(EventArgs.Empty);
 73         Console.WriteLine("结束处理");
 74         this.OnEndProcess(EventArgs.Empty);
 75     }
 76 }
 77 －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
 78 internal class Program
 79 {
 80     private static void Main(string[] args)
 81     {
 82         ProcessPipleline process = new ProcessPipleline();
 83         process.StartProcess += new EventHandler(process_StartProcess);
 84         process.PreProcess += new EventHandler(process_PreProcess);
 85         process.PostProcess += new EventHandler(process_PostProcess);
 86         process.EndProcess += new EventHandler(process_EndProcess);
 87         Console.ReadLine();
 88     }
 90     private static void process_StartProcess(object sender, EventArgs e)
 91     {
 92         Console.WriteLine("开始处理的事件处理.....");
 93     }
 95     private static void process_PreProcess(object sender, EventArgs e)
 96     {
 97         Console.WriteLine("处理前的事件处理....");
 98     }
100     private static void process_PostProcess(object sender, EventArgs e)
101     {
102         Console.WriteLine("处理后的事件处理......");
103     }
105     private static void process_EndProcess(object sender, EventArgs e)
106     {
107         Console.WriteLine("处理完成的事件处理.....");
108     }
109 }

3.HttpApplication的处理管道

　　1) HttpApplication对象是ASP.NET中处理请求的重要对象，HttpApplication对象提供了19个标准事件，参考资料：http://www.cnblogs.com/OceanEyes/archive/2012/08/23/2651790.html

　　2)19个事件处理过程的简单介绍如下：

　　　　1)在ASP.NET中，ASP.NET服务器对于每一次请求的处理都是相同的，都要经过HTTPApplication的处理管道，管道内部的处理过程是固定的，在服务器处理请求的各个阶段，伴随着处理的进行，以此触发对应的时间。

　　　　2)关于19个管道事件的资料去网上查找学习。

　　3) HttpContext状态管理

　　　　a.我们知道，HttpContext通过属性User和Handler传递了当前请求的用户和处理请求所使用的处理程序信息，如果我们还需要从HttpApplication前面的事件向后面的事件处理程序传递一些参数，那么我们可以通过HttpContext的Items属性来完成。

　　　　b.HttpContext类中定义了一个Items属性，这是一个字典，其定义如下：

　　　　　　public IDictionary Items{get;}

　　　　c.由于HttpContext对象贯穿整个HttpApplication的处理过程，所以，可以借助于这个属性，从处理过程的前面的步骤中，将数据传递给后面的处理步骤，而不需要通过方法的参数或者对象的成员，这种传递参数的方式称为基于HttpContext的状态管理。