c#之委托總結

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.向方法 里面添加 委托
            tran = new Translate(TranSlateCN);//創建委托
            //tran = TranSlateCN;//第二種創建委托的方法（效果同上）

            tran.Invoke("北疆");//實現委托的方法
            tran("北疆");//調用 委托事件(實現的 就是上面的 方法)

 

匿名的方式給委托賦值：

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

 

 

 3、委托的作用：

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

演示：實現不同排序方法

首先定義委托：

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

 

定義排序函數：

        public object GetMax(object[] objs, GetMaxDel maxdel)
        {
            object maxobj = objs[0];
            foreach (var item in objs)
            {
                if (maxdel(item, maxobj) > 0)
                {
                    maxobj = item;
                }
            }
            return maxobj;
        }

 

第一種排序：

            GetMaxDel maxdel1 = delegate(object o1, object o2)
            {
                int num1 = Convert.ToInt32(o1);
                int num2 = Convert.ToInt32(o2);
                return num1 - num2;
            };

            object[] objs = { 4, 1, 7, 3, 2 };
            object result = d.GetMax(objs, maxdel1);

            Console.WriteLine(result.ToString());

 

第二種排序

            GetMaxDel maxdel2 = delegate(object o1, object o2)
            {
                Person p1 = o1 as Person; //Person是實現定義的類
                Person p2 = o2 as Person;
                if (p1.Age > p2.Age)
                    return 1;
                else
                    return -1;
            };

 

 

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

有返回值的泛型委托

            List<int> listInt = new List<int>() { 1, 2, 3, 4, 5 };
            //有返回值的 泛型委托。（使用的最多）
            //前面可以傳遞 最多 （出入參數）十六參數   最后一個傳出參數（out 類型）的是bool類型的（判斷是否滿足要求）
            Func<int, bool> funcdel = a => a > 2;
            //函數原型：public delegate TResult Func<in T, out TResult>(T arg);  實質：也是委托，只不過對 傳入參數 和返回值 做了約束


            //List  的where方法（用戶篩選 List里面 的 滿足 泛型 委托 函數的 ）
            var result = listInt.Where(funcdel);
            foreach (var i in result)
            {
                Console.WriteLine(i);
            }

 

 無返回值的泛型委托：

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

 

 

6、異步委托

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

第一種：不使用回調函數

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

 

第二種：使用回調函數

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

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

 

執行異步委托：

            newdel.BeginInvoke(2, 3, new AsyncCallback(ForSayCallBack), 3);//最后一個參數（object類型：可以傳遞多個值（比如傳遞一個List類型）） :為回調函數傳值

            //(**)BeginInvoke內部實現:第一步：從線程池 里面 拿過來一個 新的線程  第二步：用此線程 執行 當前委托（調用異步委托的委托）要執行的方法  第三步：執行 回調函數 
            Console.WriteLine("主線程執行完畢！");