c#之委托總結

1、委托的聲明和編譯原理

聲明委托：

1 delegate void Translate(string str);

通過反編譯之后可得下面代碼

    PRivate sealed class Translate:System.MulticastDelegate//就是一個多播委托    {        public Translate(object o, Method m) { }//（實現委托方法），隱性傳進來的 o 就是 當前類的 this對象，第二個參數是傳進來的事件        public void Invoke(string str) { }//實現  委托的方法(向委托事件里面 傳遞參數)     // 所以可以通過 new 調用  委托業務函數 ，可以 調用 Invoke()方法來實現    }

委托是由三部分組成：1、Target（指向方法的實例（就是方法的類），對應上面的 o）2、Method（指向方法的 類型） 3、委托鏈（InvorkList）：多播委托。委托時一個object數組，每增加一個方法，實際CLR會將其封裝成一個委托，將其添加到object[]中。然后調用的時候，通過“類型指針”指向對應的委托的地址，然后指針在向下指向下一個委托，知道數組中所有委托都執行完畢。）

2、委托的使用

1            //1.向方法 里面添加 委托2             tran = new Translate(TranSlateCN);//創建委托3             //tran = TranSlateCN;//第二種創建委托的方法（效果同上）4 5             tran.Invoke("北疆");//實現委托的方法6             tran("北疆");//調用 委托事件(實現的 就是上面的 方法)

匿名的方式給委托賦值：

            AddDel adddemo2 = delegate(int c, int b)            {                return c + b;            };

3、委托的作用：

占位：向一個方法函數中傳遞一個委托類型的變量，因為方法函數中不知道要執行什么方法，但是知道方法的類型，所以用一個委托作為形參傳遞進去，然后實參由使用的用戶自行定義，只要符合委托類型就可以了。（實際上：就是傳遞進去一個委托類型的形參，就可以傳遞不同的（只要符合委托類型）的實參方法。）

演示：實現不同排序方法

首先定義委托：

    public delegate int GetMaxDel(object o1, object o2);

定義排序函數：

 1         public object GetMax(object[] objs, GetMaxDel maxdel) 2         { 3             object maxobj = objs[0]; 4             foreach (var item in objs) 5             { 6                 if (maxdel(item, maxobj) > 0) 7                 { 8                     maxobj = item; 9                 }10             }11             return maxobj;12         }

第一種排序：

 1             GetMaxDel maxdel1 = delegate(object o1, object o2) 2             { 3                 int num1 = Convert.ToInt32(o1); 4                 int num2 = Convert.ToInt32(o2); 5                 return num1 - num2; 6             }; 7  8             object[] objs = { 4, 1, 7, 3, 2 }; 9             object result = d.GetMax(objs, maxdel1);10 11             Console.WriteLine(result.ToString());

第二種排序

1             GetMaxDel maxdel2 = delegate(object o1, object o2)2             {3                 Person p1 = o1 as Person; //Person是實現定義的類4                 Person p2 = o2 as Person;5                 if (p1.Age > p2.Age)6                     return 1;7                 else8                     return -1;9             };

4、多播委托

委托含有一個“委托鏈”，是一個object[]類型的數組，執行的之后，委托的“類型指針”（方法指針）會執行下一個委托，一次類推，執行完成所有的委托

            SayHi sayhi = new SayHi(d.SayHiInChinese);            //  sayhi = (SayHi) Delegate.Combine(sayhi, new SayHi(d.SayHiInEnglish));  反編譯之后：所以執行的還是兩個委托 相加            sayhi += d.SayHiInEnglish;            sayhi += d.SayHiInFresh;            sayhi("大家好");            sayhi -= d.SayHiInFresh; //調用的是Delegate.Remove(new Delegate(d.SayHiInFresh));            //下面是  將方法 封裝成 委托 在進行相加（和上面直接加 方法 是一樣的（編譯成相同的代碼））            SayHi sayhello = new SayHi(d.SayHiInFresh);            //兩個委托相加            sayhi += sayhello;

注意：多播委托的委托最好不要要返回值。如果有返回值，那么執行多播委托的時候，多播委托的返回值是最后一個委托方法執行的返回值。

5、泛型委托

泛型：就是約束：約束的是傳入的參數的個數類型和返回值的類型。

分為兩種：有返回值泛型委托：Func 和 無返回的泛型委托：Action

有返回值的泛型委托

 1             List<int> listInt = new List<int>() { 1, 2, 3, 4, 5 }; 2             //有返回值的 泛型委托。（使用的最多） 3             //前面可以傳遞 最多 （出入參數）十六參數   最后一個傳出參數（out 類型）的是bool類型的（判斷是否滿足要求） 4             Func<int, bool> funcdel = a => a > 2; 5             //函數原型：public delegate TResult Func<in T, out TResult>(T arg);  實質：也是委托，只不過對 傳入參數 和返回值 做了約束 6  7  8             //List  的where方法（用戶篩選 List里面 的 滿足 泛型 委托 函數的 ） 9             var result = listInt.Where(funcdel);10             foreach (var i in result)11             {12                 Console.WriteLine(i);13             }

無返回值的泛型委托：

1             //無返回值的  泛型委托 Action，，很少使用2             //委托的 函數原型：public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);3             Action<int, int> act = (a, b) => {4                 Console.WriteLine(a+"+"+b+"+"+(a+b));5             };6             act.Invoke(2,3);

6、異步委托

什么是異步委托：當當前主線程執行的時候，定義一個新的 線程，執行相應的代碼，但是不影響主線程。

第一種：不使用回調函數

 1             //第一種（EndInvoke會阻塞當前線程（主線程）） 2             //異步委托：就是 當主線程 執行的時候， 定義 一個新的線程執行 代碼，不影響 主線程的 運行 3             IAsyncResult delResult = newdel.BeginInvoke(3, 4, null, null);//返回值為  異步委托的結果 4             while (!delResult.IsCompleted) 5             { 6                 //當 異步委托 沒有執行完成的 時候 主線程  可以繼續執行  自己的代碼 7             } 8             //執行 委托的 EndInvoke 方法 之后返回值就是  委托傳進來的 參數方法的  返回值 9             int addResult = newdel.EndInvoke(delResult);//阻塞當前線程的 執行（直到 異步委托執行完成之后）10             Console.WriteLine("線程執行完成之后 的結果" + addResult);

第二種：使用回調函數

首先為回調函數定義方法：

 1         //為回調函數 定義 一個方法（根據委托類型  來定義方法 （void 還有參數為 接口）） 2         public static void ForSayCallBack(IAsyncResult iasyResult) 3         { 4             //將接口類型 轉換成  實例類型（只要是繼承與 此接口的 類 都可以將  接口參數  轉換成 實例類型）（*面向接口編程*） 5             AsyncResult asyResult = iasyResult as AsyncResult; 6             //AsyncDelegate:獲取 對應的 委托對象  （并將 獲得的委托對象  轉換成 自己定義的 委托對象） 7             myNewdel mydel= asyResult.AsyncDelegate as myNewdel; 8             //獲得了自己的 委托對象 就可以調用  EndInvoke方法了 9             int result= mydel.EndInvoke(iasyResult);10             Console.WriteLine("次異步委托執行了，執行的返回結果為{0},線程Id為：{1}",result,11                 Thread.CurrentThread.ManagedThreadId);12             //取到 為回調函數  傳遞的值(**)13             int state =(int) iasyResult.AsyncState;14         }

執行異步委托：

1             newdel.BeginInvoke(2, 3, new AsyncCallback(ForSayCallBack), 3);//最后一個參數（object類型：可以傳遞多個值（比如傳遞一個List類型）） :為回調函數傳值2 3             //(**)BeginInvoke內部實現:第一步：從線程池 里面 拿過來一個 新的線程  第二步：用此線程 執行 當前委托（調用異步委托的委托）要執行的方法  第三步：執行 回調函數 4             Console.WriteLine("主線程執行完畢！");