C#委託，事件與回調函數

 .Net編程中最經常用的元素，事件必然是其中之一。無論在ASP.NET還是WINFrom開發中，窗體加載(Load),繪製(Paint),初始化(Init)等等。
“protected void Page_Load(object sender, EventArgs e)”這段代碼相信沒有人不熟悉的。細心一點一定會發現，非常多的事件方法都是帶了“object sender, EventArgs e”這兩個參數。這是不是和委託非常相似呢？

一、委託（有些書中也稱爲委派）

委託是什麼呢？這個名字的意思已經賦予了我們想象的空間，你是編程的，你現在正在寫一個ASP.NET網頁，而JS是你不熟悉的，於是你委託你的一位同事來幫助你完成JS部分。這就是委託，把你所不能做的事情交給其他人去做。而怎麼知道是哪個人去做呢？當然是要知道名字！而爲了區別名字一樣的不同人，因此，需要描述一個特徵。

在C#中，委託的作用是這樣描述的：委託就像一個函數的指針，在程序運行時可以使用它們來調用不同的函數。這個其實和你委託同事完成 JS代碼一樣。如果有兩位同事可以做這件事情，他們只要做的結果能夠滿足你的需求（就像一個接口），儘管他們做的過程不一樣，並且作出的效果也不一樣，但是，能夠達到你的要求就可以了。

1、簡單的委託

那委託需要承載哪些信息呢？首先，它存儲了方法名，還有參數列表(方法簽名),以及返回的類型。比如：
delegate string/*返回類型*/ ProcessDelegate(int i);
這就是一個委託的定義。藍色部分是聲明委託的關鍵字，紅色部分是返回的類型，而黑色部分是委託的類型名，和一個類名差不多，而()裏的就是參數部分。它的意思是，你要使用這個委託來做事情的話，那麼，做事情的方法必須滿足以下條件：
1、返回類型和委託的返回類型一致，這裏是string類型；
2、能且只能有一個參數，並且是int類型。
OK,滿足以上兩個條件，一切就可以工作了:)

例如：

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 
 5 namespace TestApp
 6 {
 7     /// <summary>
 8     /// 委託
 9     /// </summary>
10     /// <param name="s1"></param>
11     /// <param name="s2"></param>
12     /// <returns></returns>
13     public delegate string ProcessDelegate(string s1, string s2);
14 
15     class Program
16     {
17         static void Main(string[] args)
18         {
19             /*  調用方法  */
20             ProcessDelegate pd = new ProcessDelegate(new Test().Process);
21             Console.WriteLine(pd("Text1", "Text2"));
22         }
23     }
24 
25     public class Test
26     {
27         /// <summary>
28         /// 方法
29         /// </summary>
30         /// <param name="s1"></param>
31         /// <param name="s2"></param>
32         /// <returns></returns>
33         public string Process(string s1,string s2)
34         {
35             return s1 + s2;
36         }
37     }
38 }

輸出的結果是:
Text1Tex2


2、泛型委託

泛型的委託，就是然參數的類型不確定,例如代碼改寫爲：

using System;
using System.Collections.Generic;
using System.Text;

namespace TestApp
{
    /// <summary>
    /// 委託
    /// </summary>
    /// <param name="s1"></param>
    /// <param name="s2"></param>
    /// <returns></returns>
    public delegate string ProcessDelegate<T,S>(T s1, S s2);

    class Program
    {
        static void Main(string[] args)
        {
            /*  調用方法  */
            ProcessDelegate<string,int> pd = new ProcessDelegate<string,int>(new Test().Process);
            Console.WriteLine(pd("Text1", 100));
        }
    }

    public class Test
    {
        /// <summary>
        /// 方法
        /// </summary>
        /// <param name="s1"></param>
        /// <param name="s2"></param>
        /// <returns></returns>
        public string Process(string s1,int s2)
        {
            return s1 + s2;
        }
    }
}

輸出的結果就是：
Text1100

泛型的詳細內容不屬於本文的介紹範圍，這裏不加多說了。

二、事件

在某件事情發生時，一個對象可以通過事件通知另一個對象。比如，前臺完成了前臺界面，他通知你，可以把前臺和你開發的程序整合了。這就是一個事件。可以看出事件是在一個時間節點去觸發另外一件事情，而另外一件事情怎麼去做，他不會關心。就事件來說，關鍵點就是什麼時候，讓誰去做。

在C#中，時間定義關鍵字是event。例如：
event ProcessDelegate ProcessEvent;

整個事件定義方法以及執行過程：

using System;
using System.Collections.Generic;
using System.Text;

namespace TestApp
{
    /// <summary>
    /// 委託
    /// </summary>
    /// <param name="s1"></param>
    /// <param name="s2"></param>
    /// <returns></returns>
    public delegate void ProcessDelegate(object sender, EventArgs e);

    class Program
    {
        

        static void Main(string[] args)
        {
            /*  第一步執行  */
            Test t = new Test();
            /* 關聯事件方法，相當於尋找到了委託人 */
            t.ProcessEvent += new ProcessDelegate(t_ProcessEvent);
            /* 進入Process方法 */
            Console.WriteLine(t.Process()); 

            Console.Read();
        }

        static void t_ProcessEvent(object sender, EventArgs e)
        {
            Test t = (Test)sender;
            t.Text1 = "Hello";
            t.Text2 = "World";
        }
    }

    public class Test
    {
        private string s1;

        public string Text1
        {
            get { return s1; }
            set { s1 = value; }
        }

        private string s2;

        public string Text2
        {
            get { return s2; }
            set { s2 = value; }
        }


        public event ProcessDelegate ProcessEvent;

        void ProcessAction(object sender, EventArgs e)
        {
            if (ProcessEvent == null)
                ProcessEvent += new ProcessDelegate(t_ProcessEvent);
            ProcessEvent(sender, e);
        }

        //如果沒有自己指定關聯方法，將會調用該方法拋出錯誤
        void t_ProcessEvent(object sender, EventArgs e)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        void OnProcess()
        {
            ProcessAction(this, EventArgs.Empty);
        }

        public string Process()
        {
            OnProcess();
            return s1 + s2;
        }
    }
}
 

感覺到了什麼？是不是和代碼注入了差不多，相當於是可以用任意符合委託接口(委託確實很像接口)的代碼，注入到Process過程。在他返回之前給他賦值。

三、回調函數

打了這麼多字，好累啊!

回調函數就是把一個方法的傳給另外一個方法去執行。在C#有很多回調函數，比如異步操作的時候。這裏先舉個例子：

using System;
using System.Collections.Generic;
using System.Text;

namespace TestApp
{
    /// <summary>
    /// 委託
    /// </summary>
    /// <param name="s1"></param>
    /// <param name="s2"></param>
    /// <returns></returns>
    public delegate string ProcessDelegate(string s1, string s2);

    class Program
    {
        static void Main(string[] args)
        {
            /*  調用方法  */
            Test t = new Test();
            string r1 = t.Process("Text1", "Text2", new ProcessDelegate(t.Process1));
            string r2 = t.Process("Text1", "Text2", new ProcessDelegate(t.Process2));
            string r3 = t.Process("Text1", "Text2", new ProcessDelegate(t.Process3));

            Console.WriteLine(r1);
            Console.WriteLine(r2);
            Console.WriteLine(r3);
        }
    }

    public class Test
    {
        public string Process(string s1,string s2,ProcessDelegate process)
        {
            return process(s1, s2);
        }

        public string Process1(string s1, string s2)
        {
            return s1 + s2;
        }

        public string Process2(string s1, string s2)
        {
            return s1 + Environment.NewLine + s2;
        }

        public string Process3(string s1, string s2)
        {
            return s2 + s1;
        }
    }
}

輸出結果：
Text1Text2
Text1
Text2
Text2Text1

Process方法調用了一個回調函數，當然這裏只執行了回調函數。可以看出，可以把任意一個符合這個委託的方法傳遞進去，意思就是說這部分代碼是可變的。而設計上有一個抽離出可變部分代碼的原則，這種用法無疑可以用到那種場合了。

 

來自：http://www.cnblogs.com/birdshover/archive/2008/01/07/1029471.html