深入淺出之委托

一、什么是委托

        源碼下載

       1.委托是面向對象的、類型安全的，是引用類型。使用delegate關鍵字進行定義。委托的本質就是一個類，繼承自System.MulticastDelegate，而它又派生自System.Delegate。里面內置了幾個方法 ，可以在類的外面聲明委托，也可以在類的內部聲明委托。

對委托的使用：先定義，后聲明和實例化委托，然后作為參數傳遞給方法。

二、委托定義

       1.委托就是一個類，別把它想成了方法，所以不能重載。委托也不能繼承因為是密封類。

namespace MyDelegation
{
    /// <summary>
    /// 委托
    /// </summary>
    //定義來了一個全局的委托 無參無返回值
    //特點就是在本類的所有方法調用
    public delegate void MyDelegate();

    /// <summary>
    /// 1:這里的無參，無返回值，表示傳遞的方法是一個沒有參數，沒有返回值的方法。
    /// 2:委托就是一個類，別把它想成了方法，所以不能重載。委托也不能繼承因為是密封類。
    /// 3:不要在方法使用委托，委托在傳遞此方法。
    /// </summary>
    public class MyDelegationDeom
    {

        /// <summary>
        /// 無參無返回值
        /// </summary>
        public delegate void MyDelegate();

        /// <summary>
        /// 有參無返回值
        /// </summary>
        public delegate void MyDelegat1(int x);

        /// <summary>
        /// 有參有返回值
        /// </summary>
        public delegate int MyDelegate2(int x);

        /// <summary>
        /// 無參有返回值
        /// </summary>
        public delegate int MyDelegate3();

        /// <summary>
        /// 泛型委托
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="t"></param>
        public delegate void MyDelegate<T>(T t);

        /// <summary>
        /// 方法
        /// </summary>
        public void Show()
        {
            //MyDelegate myDelegate = new MyDelegate(Show);
            //myDelegate.Invoke();
            Console.WriteLine("Hello World!");
        }

    }
}

三、委托的聲明與使用

       1.實例化聲明，等於聲明，多播聲明。傳入方法的方式(普通方法，還可以傳入靜態、實例方法,匿名方法)，實例傳入 方法不需要帶（）。

                //傳入方法的方式(普通方法，還可以傳入靜態、實例方法,匿名方法)
                //實例傳入 方法不需要帶（）
                MyDelegate myDelegate = new MyDelegate(new MyDelegationDeom().Show);
                myDelegate();
                //省略實例 可以直接等於但是效果是一樣的
                MyDelegate myDelegate1 = new MyDelegationDeom().Show;
                myDelegate1();
                //多播委托 委托鏈實現了，將委托用鏈連接起來，執行的使用從頭到尾執行
                MyDelegationDeom myDelegationDeom = new MyDelegationDeom();
                MyDelegate myDelegate2 = new MyDelegationDeom().Show;
                myDelegate2 += myDelegationDeom.Show;
                //多播委托也可以刪除,只要將對應的實例方法放入就可以刪除之前的添加方法
                myDelegate2 -= myDelegationDeom.Show;
                myDelegate2 -= new MyDelegationDeom().Show;
                myDelegate2.Invoke();

       2.委托方法調用，可以使用Invoke（）方法，或者直接使用委托實例（）。

//委托調用方式
            {
                MyDelegate myDelegate1 = new MyDelegationDeom().Show;
                //調用Invoke方法 
                myDelegate1.Invoke();
                //直接調用  
                //和上面兩個方法一致的效果,也有一步調用方法。
                myDelegate1();
            }

       3.多播委托是最為特殊的可以使用+=、-=進行添加委托鏈，顧名思義就是添加一個委托，刪除一個委托（如果刪除沒有找到對應的委托不會報錯）下面的代碼中我們先添加了兩個方法進入委托，然后使用-=刪除了兩個方法我們執行還是執行了一個方法。這個是為什么呢小老弟？你們覺得是什么問題？

                //多播委托 委托鏈實現了，將委托用鏈連接起來，執行的使用從頭到尾執行
                MyDelegationDeom myDelegationDeom = new MyDelegationDeom();
                MyDelegate myDelegate2 = new MyDelegationDeom().Show;
                myDelegate2 += myDelegationDeom.Show;
                //多播委托也可以刪除,只要將對應的實例方法放入就可以刪除之前的添加方法
                myDelegate2 -= myDelegationDeom.Show;
                myDelegate2 -= new MyDelegationDeom().Show;
                myDelegate2.Invoke();

 

         4.上面我們使用多播委托的時候在+=方法的時候使用new MyDelegationDeom().Show 我們都知道New創建的對象都是不同的，所以在下面刪除的時候找不到，就不能刪除對應的委托了。

         5.我們可以明顯的發現new MyDelegationDeom().Show這個方法使用一次還要去定義方法，會使代碼冗余、繁瑣。在不斷的簡化中產生了lambda表達式,lambda表達式就是方法的縮寫，簡化的順序就是從上往下，執行的效果和作用與之前的一樣。

 

MyDelegate myDelegate4 = new MyDelegate(() => { Console.WriteLine("哈哈"); });
                myDelegate4.Invoke();
                MyDelegate myDelegate5 = () => { Console.WriteLine("哈哈"); };
                myDelegate5.Invoke();
                MyDelegate myDelegate6 = () => Console.WriteLine("哈哈");
                myDelegate6.Invoke();
                //有參無返回值
                MyDelegate1 myDelegate7 = (x) => Console.WriteLine("哈哈");
                myDelegate7.Invoke(5);
                MyDelegate1 myDelegate8 = x => Console.WriteLine("哈哈");
                myDelegate8.Invoke(5);
                //有參有返回值 如果是兩個參數的話就一定要加（）了。
                MyDelegate2 myDelegate9 = x => x;
                myDelegate9.Invoke(5);

三、委托情景對話

         1.假如我們有一個數據集合我們需要過濾成績大於200分和學生名字長度大於2的學生，各位你們的做法是不是和我下面寫的一樣呢？小老弟

    /// <summary>
    /// 學生類
    /// </summary>
    public class Student
    {
        /// <summary>
        /// 主鍵
        /// </summary>
        public int ID { get; set; }
        
        /// <summary>
        /// 名稱
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 成績
        /// </summary>
        public int Score { get; set; }
    }

//假如我們有一個數據集合我們需要過濾成績大於200分的學生
                //總數據源
                List<Student> data = new List<Student>();

                //需要拿出來的數據
                List<Student> students = new List<Student>();
                //賽選數據
                data.ForEach(x =>
                {
                    if (x.Score > 200)
                    {
                        students.Add(x);
                    }
                    else if (x.Name.Length > 2)
                    {
                        students.Add(x);
                    }
                });

         2.但是突然有一天產品粑粑說我要改需求，老師可以動態的選中篩選條件？我們第一時間會感覺我是誰，我在哪里，我在做什么？懷疑完之后我們還是要想解決方案去做，剛剛大家既然已經學習了委托，我們知道委托可以動態傳遞方法。那么我們是不是可以將判斷條件放到外面去做，我們將公共的代碼復用呢？

        /// <summary>
        /// 定義一個委托 有參有返回值 我們首先定義一個委托，參數是學生，返回的bool
        /// </summary>
        public delegate bool MyDelegateDecide(Student student);

            //只需要改變委托的傳值，其他的不要修改了,加入滿足了某個條件我們就添加某個判斷。
            MyDelegateDecide myDelegateDecide = x => x.Score > 200;
            myDelegateDecide += x => x.Name.Length > 2;
            //委托解耦
            {
                //假如我們有一個數據集合我們需要過濾成績大於200分的學生
                //總數據源
                List<Student> data = new List<Student>();
                GetData(data, myDelegateDecide);
            }

/// <summary>
        /// 獲取數據源
        /// </summary>
        /// <param name="data"></param>
        /// <param name="myDelegateDecide"></param>
        static List<Student> GetData(List<Student> data, MyDelegateDecide myDelegateDecide)
        {
            //需要拿出來的數據
            List<Student> students = new List<Student>();
            //賽選數據
            data.ForEach(x =>
            {
                if (myDelegateDecide.Invoke(x))
                {
                    students.Add(x);
                }
            });
            return students;
        }

四、委托漸入佳境（Action、Func 委托）

        1.Action是一個有參無返回值的委托  ，Func是一個有參（或者無參）並且有返回值的委托，共同點就是，都有默認最多16個參數，如果以后還想17就需要自己重新這個類。

    　 2.首先說一下為什么我們在平常開發中基本不會自己定義委托了，如果看了GetData的代碼，我們明顯的發現，我們定義的委托類型就寫死了，不方便以后的靈活使用.net 就給我們提供了兩個標准委托。

        3.好處，我們使用起來會更加方便，統一了我們委托編碼的規范 。

{
                Action action = () => { Console.WriteLine("無參無返回值"); };
                action.Invoke();
                Action<int> action1 = x => { Console.WriteLine("有參無返回值"); };
                action1.Invoke(5);
                Action<int, int> action2 = (x, y) => { Console.WriteLine("有參無返回值"); };
                action2.Invoke(1,2);
                Func<int, bool> func = x => true;
                func.Invoke(5);
            }

五、這不是和委托經常一起出現的事件嗎？

         1.事件的定義，我們可以很清楚的看到，定義事件我們先要定義一個委托，然后在使用event定義事件。各位道友是不是感覺事件好像就是委托的一個實例呢？

         2.事件不能再聲明事件以外的地方調用方法Invoke 、已經不能直接修改事件的方法，只能+= 防止別人修改內部代碼 private 繼承都沒有用。

         3.事件 重點：委托和事件的區別就在，事件是委托的實例

        /// <summary>
        /// 定義一個委托 無參無返回值
        /// </summary>
        public delegate void MyMaoDeom();

        /// <summary>
        /// 事件 委托和事件的區別就在，事件是委托的實例
        /// </summary>
        public event MyMaoDeom MyMaoDeomEvent;

六、事件情景（觀察者模式）

        1.小蘭有一只貓，當它叫的時候會，發生飛、跑、游泳的動作

/// <summary>
        /// 貓叫了發生動作
        /// </summary>
        public void Call()
        {
            Console.WriteLine("貓叫了發生動作");
            Movement movement = new Movement();
            movement.Fly();
            movement.Run();
            movement.Swimming();
        }

 　　2.我們剛開始可能會這樣寫，直接寫一個方法調用下面的動作，但是有一個我們正在吃着泡面改着bug產品粑粑說不行這個需求需要修改，當小蘭的貓叫的時候我想先游泳、然后跑、在然后小蘭的貓就飛走啦。相信大家看着產品粑粑眼神從蒙圈，再到了驚訝，然后在苦苦哀求產品粑粑放過我們把。

//事件 重點：委托和事件的區別就在，事件是委托的實例
            //事件不能再聲明事件以外的地方調用方法Invoke 、已經不能直接修改事件的方法，只能+= 防止別人修改內部代碼
            {
                //這個是直接調用的模式，但是缺點就是下次貓叫發生的動作想要發生變化的時候就需要
                //修這個類的方法，麻煩為了方便日后維護，我們需要將以后需要改動的東西抽了出來
                Miao miao = new Miao();
                miao.Call();

                //這里的話我們要使用事件來進行
                //這里其實就是一個典型的觀察者模式，就是使用事件多播，達到動態的執行一些動作
                //很多地方都使用了這樣的思想。
                Movement movement = new Movement();
                miao.MyMaoDeomEvent += movement.Swimming;
                miao.MyMaoDeomEvent += movement.Fly;
                miao.MyMaoDeomEvent += movement.Run;
                miao.CallNew();
            }

/// <summary>
        /// 貓叫了發生動作
        /// </summary>
        public void CallNew()
        {
            Console.WriteLine("貓叫了發生動作");
            Movement movement = new Movement();
            if (MyMaoDeomEvent != null)
            {
                MyMaoDeomEvent.Invoke();
            }
        }

最終我們使用了我們今天所學習的事件，實現了產品粑粑的需求。（這里大家可能會問為什么我們不用委托呢？這里使用事件主要是防止他人在外面對委托進行修改，為了安全保障。所以才會出現事件的。）

七、有始有終

       1.今天我們學習了委托，相信大家和我一樣都會有自己的收獲，在這一段時間里我們發現了很多時候，我們寫的代碼都是一樣的，但是就不同於有的代碼很簡潔，有的代碼很冗余，我們要有一種將重復的東西封裝將（不可以控制、經常變的數據）分離出來使用動態的手段進行傳遞。