事件

前言

　　對於搞.net的朋友來講，常常會遇到關於事件和委託的問題：事件與委託有什麼關係？事件的本質是什麼？委託的本質又是什麼？因爲.net 作了大量的封裝，對於初學者，這兩個概念確實不怎麼好理解。事件是用戶與應用程序交互的基礎，它是回調機制的一種應用。舉個例子，當用戶點擊按鈕時，咱們但願彈出一句「您好」；這裏的【點擊】就是一個事件；那麼回調就是咱們註冊一個方法，當用戶點擊時，程序自動執行這個方法去響應這個操做，而不是咱們時刻去監聽用戶有沒有點擊。

　　上一篇已經介紹了委託的相關知識，它就是.net用來實現回調機制的技術，而事件又是回調機制的一種應用，在學習事件前，應該先學習好委託的知識。有了委託的基礎，接下來就讓咱們一步步走進事件。

1、使用事件

　　假設場景：有一個郵件管理員（事件擁有者），它賦值接收郵件，當郵件到來時（事件），郵件能夠交給傳真員和打印員處理（事件訂閱者）。很明顯，郵件到來的時間只有郵件管理員知道，傳真員和打印員也不可能時刻去詢問有沒有新郵件，而是應該由管理員主動來通知（回調），但他們也要先告訴管理員，新郵件到來時，我須要處理（訂閱）。這裏接收新郵件就是一個事件，郵件有必定的信息（事件附加信息），例如：發送人、接收人，內容。接下來咱們經過這個過程來了解事件。

　　1. 定義事件所須要的附加信息

　　按照約定，全部的事件的附加信息都應該從EventArgs派生，由於咱們但願一看就知道這是個事件附加信息參數，而不是其它的。EventArgs的定義以下：

     public class EventArgs {
        public static readonly EventArgs Empty = new EventArgs();
        public EventArgs() {}
    }

　　能夠看到，該類有一個靜態只讀字段Empty，這是一個單例；與String.Empty同樣，當咱們須要一個空的EventArgs時，應該使用EventArgs.Empty，而不是從新去new一個。

　　咱們定義一個NewMailEventArgs參數，以下：

    class NewMailEventArgs : EventArgs
    {
        private string from;
        private string to;
        private string content;

        public string From { get { return from; } }
        public string To { get { return to; } }
        public string Content { get { return content; } }

        public NewMailEventArgs(string from,string to,string content)
        {
            this.from = from;
            this.to = to;
            this.content = content;
        }
    }

　　2. 定義事件

　　c#裏定義事件用到了event關鍵字，並且事件通常都是公開類型的。咱們定義一個NewMail事件以下：

public event EventHandler<NewMailEventArgs> NewMail;

　　咱們說NewMail是一個事件，但.net並無事件這種類型。實際上，這裏它是一個EventHandler<TEventArgs>委託（委託又是引用類型），只不過用了event進行修飾，也能夠說它是一種具備事件性質的委託。

　　咱們知道委託是用來包裝回調函數的，它的本質是一個class，回調函數的簽名必須與委託的簽名一致。一個事件能夠有多個處理函數，一個函數就會被包裝成一個委託對象，全部的委託對象都保存在NewMail的委託鏈當中。因此，觸發NewMail事件，其實就是遍歷其指向的委託對象的委託鏈，執行每一個委託對象所包裝的方法。(不清楚能夠看委託)

　　EventHandler 是個泛型委託，他的定義以下：

public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e);

　　這裏有兩個特色：1. 返回值是void，這是由於事件處理函數通常不須要有返回值，.net中大部分的事件處理函數都是沒有返回值的。2. object類型的sender參數，這表示事件的擁有者；這也很符合邏輯，咱們除了要拿到實際的附加信息外，還要知道事件是從哪裏來的；至於爲何是object類型的，是由於這樣能夠給更多的類型使用。

　　3. 定義事件觸發函數　　

         //3.定義觸發事件的方法
        protected virtual void OnNewMail(NewMailEventArgs e)
        {
            /* 第1種作法             
             if(this.NewMail != null)
             {
                this.NewMail(this,e);
             }             
             */
            
            /* 第二種作法
            EventHandler<NewMailEventArgs> temp = this.NewMail;
            if (temp != null)
            {
                temp(this, e);
            }
            */

            //第三種作法
            EventHandler<NewMailEventArgs> temp = Interlocked.CompareExchange(ref this.NewMail, null, null);
            if (temp != null)
            {
                temp(this, e);
            }
        }

　　第一種作法是很常見的作法，判斷不爲空，而後就觸發。CLR裏提到這是線程不安全的作法，由於單咱們判斷不爲空後，準備執行時，另外一個線程將從委託鏈將委託移除，此時變成了空，引起NullReferenceException異常。第2、三種作法都是線程安全的，由於它經過一個臨時委託變量（委託鏈保存了全部委託），經過上一篇對委託鏈的瞭解，咱們知道對委託鏈進行Combine/Remove實際都會建立一個新的數組對象，此時對temp沒有影響。但實際上事件主要在單線程的環境下使用，因此通常也不會出現這種問題。

　　4. 包裝好事件參數，調用事件觸發函數。

        public void ReceiveNewMail(string from, string to, string content)
        {
            NewMailEventArgs e = new NewMailEventArgs(from, to, content);
            OnNewMail(e);
        }

　　接下來，對該事件感興趣的，就能夠對該事件進行註冊。

    class Fax
    {
        public Fax(MailManager mm)
        {
            mm.NewMail += FaxMsg;
        }

        private void FaxMsg(object sender, NewMailEventArgs e)
        {
            Console.WriteLine(string.Format("fax receive，from:{0} to:{1} content is:{2}", e.From, e.To, e.Content));
        }
    }

2、事件揭祕

　　前面咱們已經提到事件的本質是委託，或者說是委託的一種應用。要深刻理解事件，咱們經過ILDasm.exe查到定義事件而生成的代碼。

public event EventHandler<NewMailEventArgs> NewMail;  

　　

　　　能夠看到當咱們定義一個NewEvent時，編譯器幫咱們生成了：1. 一個private NewMail 字段，類型爲 EventHandler<NewMailEventArgs>。 2.一個 add_NewMail 方法，用於將委託添加到委託鏈（內部調用了Delegate.Combine方法）。3.一個 remove_NewMail 方法，用於將委託從委託鏈移除（內部調用了Delegate.Remove方法）。對事件的操做，就是是對NewMail字段的操做。

　　如今咱們知道了，事件的本質就是委託，定義事件就是定義委託。只不過編譯器隱藏了這個過程。那爲何不直接使用委託呢？

3、爲何不直接用委託

　　咱們知道，事件的本質是委託，那用事件實現的地方，用委託也完成能夠實現。上面的代碼，咱們徹底可能這樣寫來達到相同的目的：

    class MailManager
    {
        public EventHandler<EventArgs> NewMail;        

        public void RaiseNewMail()
        {
            if (NewMail != null)
            {
                NewMail(this, EventArgs.Empty);
            }
        }
    }

　　外部調用：

    class Fax
    {
        public Fax(MailManager mm)
        {
            mm.NewMail += FaxNewMail;
        }

        public void FaxNewMail(object sender, EventArgs e)
        {
            Console.WriteLine("Fax New Mail 處理成功");
        }
    }

　　對於維護對象狀態的字段咱們每每不設計爲公開類型，由於外部徹底能夠隨意改變它，這不是咱們想看到的。例如上面那樣寫，咱們能夠在外部直接就調用NewMail的Invoke方法。並且對於字段，咱們沒法控制具體的獲取和設置過程，要控制就須要定義一個Get_ 方法，一個Set_方法，對於委託類型來講，就是Add_和Remove_。對於每一個事件，都去定義Add_/Remove_是很是麻煩的。說到這裏咱們會立刻連想到屬性的設計，沒錯，屬性是用Get_/Set_方法提供訪問私有字段（非委託）的方法，事件就是用Add_/Remove_方法提供訪問私有委託字段的方法。

4、顯示實現事件

 　　咱們知道隱式實現屬性時，編譯器會爲咱們生成一個private的字段，例如：public string Name{get;set;} 會自動生成一個 _name字段。可是咱們顯示實現時，編譯器就不會爲生成了。例以下面的寫法：

        public string Name
        {
            get{return "Tom";}
            set{}
        }

　　對於事件來講顯示實現就是：

        private EventHandler<NewMailEventArgs> _newMail;
        public event EventHandler<NewMailEventArgs> NewMail
        {
            add
            {
                _newMail += value;
            }
            remove
            {
                _newMail -= value;
            }
        }

　　Control 的 EventHandlerList

　　對於 Control 來講，它定義了大量的事件（定義事件就是定義委託），而這些事件不必定都會用到，因此這會浪費大量的內存。因此 Control 裏的事件都是顯示實現的，而且將委託保存在一個EventHandlerList集合中，這是一個key-value的集合。這樣須要處理哪些事件就只要添加相應的委託便可，看起來像是這樣的：

     class Control
    {
        private EventHandlerList events;
        protected EventHandlerList Events
        {
            get
            {
                if (this.events == null)
                {
                    this.events = new EventHandlerList();
                }
                return this.events;
            }
        }

        private static readonly object _clickEventObj = new object();
        private static readonly object _mouseOverEventObj = new object();        

        public event EventHandler<EventArgs> Click
        {
            add
            {
                this.Events.AddHandler(_clickEventObj, value);
            }
            remove
            {
                this.Events.RemoveHandler(_clickEventObj, value);
            }
        }

        public event EventHandler<EventArgs> MouseOver
        {
            add
            {
                this.Events.AddHandler(_mouseOverEventObj, value);
            }
            remove
            {
                this.Events.RemoveHandler(_mouseOverEventObj, value);
            }
        }
    }

　　也就是咱們針對每一個事件定義一個 object 類型做爲集合的key，雖然會定義許多object，但object的代價比委託的要小不少。

　　至此咱們應該知道：委託的本質是引用類型，用於包裝回調函數，委託用於實現回調機制；事件的本質是委託，事件是回調機制的一種應用。