ASP.NET本质论第二章应用程序对象学习笔记1

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)下面代码演示了如何在类中定义多个事件，并创建处理管道，代码如下：

public class ProcessPipleline : Component
{
    private static readonly object StartEvent = new object();
    private static readonly object PreProcessEvent = new object();
    private static readonly object PostProcessEvent = new object();
    private static readonly object EndEvent = new object();
    public event EventHandler StartProcess
    {
        add { this.Events.AddHandler(StartEvent, value); }
        remove { this.Events.RemoveHandler(StartEvent, value); }
    }
    public event EventHandler PreProcess
    {
        add { this.Events.AddHandler(PreProcessEvent, value); }
        remove { this.Events.RemoveHandler(PreProcessEvent, value); }
    }
    public event EventHandler PostProcess
    {
        add { this.Events.AddHandler(PostProcessEvent, value); }
        remove { this.Events.RemoveHandler(PostProcessEvent, value); }
    }
    public event EventHandler EndProcess
    {
        add { this.Events.AddHandler(EndEvent, value); }
        remove { this.Events.RemoveHandler(EndEvent, value); }
    }
    protected void OnStartProcess(EventArgs e)
    {
        if (this.Events[StartEvent] != null)
        {
            (this.Events[StartEvent] as EventHandler)(this, e);
        }
    }
    protected void OnPreProcess(EventArgs e)
    {
        if (this.Events[PreProcessEvent] != null)
        {
            (this.Events[PreProcessEvent] as EventHandler)(this, e);
        }
    }
    protected void OnPostProcess(EventArgs e)
    {
        if (this.Events[PostProcessEvent] != null)
        {
            (this.Events[PostProcessEvent] as EventHandler)(this, e);
        }
    }
    protected void OnEndProcess(EventArgs e)
    {
        if (this.Events[EndEvent] != null)
        {
            (this.Events[EndEvent] as EventHandler)(this, e);
        }
    }
    public void Process()
    {
        Console.WriteLine("开始处理");
        this.OnStartProcess(EventArgs.Empty);
        Console.WriteLine("准备处理");
        this.OnPreProcess(EventArgs.Empty);
        Console.WriteLine("正在处理中");
        Console.WriteLine("处理完成");
        this.OnPostProcess(EventArgs.Empty);
        Console.WriteLine("结束处理");
        this.OnEndProcess(EventArgs.Empty);
    }
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
internal class Program
{
    private static void Main(string[] args)
    {
        ProcessPipleline process = new ProcessPipleline();
        process.StartProcess += new EventHandler(process_StartProcess);
        process.PreProcess += new EventHandler(process_PreProcess);
        process.PostProcess += new EventHandler(process_PostProcess);
        process.EndProcess += new EventHandler(process_EndProcess);
        Console.ReadLine();
    }
    private static void process_StartProcess(object sender, EventArgs e)
    {
        Console.WriteLine("开始处理的事件处理.....");
    }
    private static void process_PreProcess(object sender, EventArgs e)
    {
        Console.WriteLine("处理前的事件处理....");
    }
    private static void process_PostProcess(object sender, EventArgs e)
    {
        Console.WriteLine("处理后的事件处理......");
    }
    private static void process_EndProcess(object sender, EventArgs e)
    {
        Console.WriteLine("处理完成的事件处理.....");
    }
}

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的状态管理。