.NET本質論（4）應用程式對象HttpApplication

當HttpContext對象創建之後，HttpRuntime將隨後創建一個用於處理請求的對象，這個對象的類型為HttpApplication. 在ASP.NET內部，HttpRuntime管理一個定義在System.Web命名空間下的HttpApplicationFactory類的實例...

　　　　當HttpContext對象創建之後，HttpRuntime將隨後創建一個用於處理請求的對象，這個對象的類型為HttpApplication.
　　　　在ASP.NET內部，HttpRuntime管理一個定義在System.Web命名空間下的HttpApplicationFactory類的實例，HttpApplicationFactory通過工廠模式管理HttpApplication對象，在HttpApplicationFactory內部維護了一個HttpApplication對象池，使得被創建的HttpApplication對象可以被重覆使用，但是，每一個HttpApplication對象每一次僅僅用於處理一個請求，這樣，對於ASP.NET程式員來說，也就不需要考慮HttpApplication中多個請求併發的處理問題了。
在實際的請求處理過程中，我們還需要進行大量的工作，例如，檢查當前的請求是由哪一個用戶發起的，以此我們就可以針對不同的用戶進行不同的處理，或者根據用戶來決定是否對用戶的請求進行處理，對於沒有許可權的用戶返回一個缺少相應許可權的回應等。如果我們在一個方法中來完成這些任務，顯然會造成方法的過度臃腫。在HttpApplication中，利用.NET中的事件機制，通過在處理過程中依次發出的多個事件，將這個處理過程分解為多個步驟，這個處理機制通常我們稱為處理管道，下麵我們將會詳細討論處理管道的內在機制和HttpApplication的多個事件。
　　1.處理管道
　　所謂的處理管道，就是處理複雜問題的時候，將處理的過程分解為多個處理步驟，我們將這種經過多個步驟的處理方式稱為處理管道。在.NET中，藉助於事件的強大威力，我們可以通過處理管道將複雜的處理步驟封裝起來，通過事件將處理過程的多個步驟給程式員以便於程式員對管理管道進行擴展。如下圖概述了HttpApplication處理管道的工作過程。

　　對於一個管道來說，它往往要暴露出大量的事件，通過這些事件，提供程式員的擴展機制。但是，對於一具有著眾多事件的類來說，定義大量的事件意味著創建對象的時候需要付出創建事件的成本，因為在.NET中，所謂的事件就是一個受限制的委托成員，定義多個事件，意味著在創建的對象中將會需要更多的存儲空間。針對這個問題，在System.ComponentModel.Component類中，提供了處理多個事件的基礎：Events屬性，它的類型為System.ComponentModel.EventHandlerList,這是一個線性的字典，當需要事件的時候，就通過key將事件保存到集合中，沒有對應的事件，就不會付出創建事件的成本，這樣，通過EventHandlerList可以在一個集合中管理多個事件對象，節省對象占用的空間，它的主要成員如下:

在使用的時候，首先從Component派生一個類，這個類將繼承Component的Events集合屬性。對於這個派生類所需要定義的每一個類，這個類將繼承Component的Event集合屬性。對於這個派生類所需要定義的每一個事件，在類中定義一個對應的作為Key的對象，以後，通過這個Key對象來訪問由Events集合管理的事件。
程式員也可以自己在類中定義一個類似的字典來完成這個任務，並不一定要從Component類中派生。如下

 public class ProcessPipeline : System.ComponentModel.Component
    {
        #region
        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();
        #endregion

        #region
        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); }
        }
        #endregion



        #region
        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);
            }
        }
        #endregion

        public void Process()
        {
            Console.WriteLine("開始處理");
            this.OnStartProcess(EventArgs.Empty);
            Console.WriteLine("準備處理");
            this.OnPreProcess(EventArgs.Empty);
            Console.WriteLine("下在處理中。。。");
            this.OnPostProcess(EventArgs.Empty);
            Console.WriteLine("處理結束");
            this.OnEndProcess(EventArgs.Empty);
        }
    }

namespace 自定義事件管道
{
    class Program
    {
        static void Main(string[] args)
        {

            ProcessPipeline process = new ProcessPipeline();
            process.StartProcess
                += new EventHandler(process_StartProcess);
            process.StartProcess
                += new EventHandler(process_StartProcess1);
            process.StartProcess
                -= new EventHandler(process_StartProcess);
            process.PreProcess
                += new EventHandler(process_PreProcess);
            process.PostProcess
                += new EventHandler(process_PostProcess);
            process.EndProcess
                += new EventHandler(process_EndProcess);
            process.Process();
            Console.ReadLine();
        }
        static void process_StartProcess(object sender, EventArgs e)
        {
            Console.WriteLine("開始處理的事件中的處理。。。");
        }


        static void process_StartProcess1(object sender,EventArgs e)
        {
            Console.WriteLine("開始處理的事件前的事件中的處理1");
        }

        static void process_PreProcess(object sender, EventArgs e)
        {
            Console.WriteLine("處理前的事件中的處理。。。");
        }
        static void process_PostProcess(object sender, EventArgs e)
        {
            Console.WriteLine("正在處理的事件中處理中。。。。");
        }
        static void process_EndProcess(object sender, EventArgs e)
        {
            Console.WriteLine("處理完成的事件處理。。。");
        }
    }
}

在ProcessPipeline類中，定義了4個事件，首先需要註意的是在類中並沒有定義4個實際的委托成員來對應事件，通過從Component派生，實際上從基類繼承了一個EventHandlerList類型的成員，通過將事件以屬性的形式來定義，並映射到EventHandlerList中不管在類中定義了多少個事件，在創建的對象實例中只需要這樣一個EventHandlerList的對象來保存事件響應的委托對象。
其次，在Process方法中，模擬了處理的過程，在處理的過程中，通過調用觸發事件的On開頭的方法，以事件的形式將處理的步驟暴露給程式員。
使用這個類的時候，對於程式員關心的處理事件，可以通過註冊事件處理方法到相應的事件上，在ProcessPipeline進行處理的過程中，相應的事件處理方法會被調用。