委托 你怎么看？

一 前言

　　對於委托給自己的感覺一直都是，知其然，而不知其所以然，而對於程序員來說，對於自己不是很了解的領域總是缺少安全感，為了有安全感於是我定好好理解一翻，

以下是自己的一點總結，如有不對，還請在評論中指出，謝謝。

 

二 自定義委托

2.1 什么是委托

　　委托和類一樣是一種用戶自定義的類型，但類表示的是數據的集合，而委托保存是的一個或多個方法 (精簡版)。

     我覺得委托像是一個快遞公司，我們只要把包裹給它，它就會幫我們送到指定的地方。而委托就是把方法賦值給它，然后在指定的地方調用委托就行了。

2.2 委托常規操作

     對於委托的一些常規操作就不多寫了，比較簡單就 一代(一段代碼)而過了。

　　

       //以下代碼包括了，聲明，創建，調用 委托，為委托增加方法 ，移除方法

       //聲明委托
        public delegate string MyDel(string name);

        static void Main(string[] args)
        {
            //創建委托對象, 並給委托對象賦值
            MyDel dele = Print;//將方法賦給委托時只需要傳遞方法名即可
            //給委托增加方法，也可以這么寫
            //MyDel dele1 = Print;
            //MyDel dele2 = Write;
            //MyDel dele3 = dele1 + dele2;
            dele += Write;
            //給委托移除方法
            dele -= Write;
            //調用委托
            dele("Zery"); 
        }  

        private static string Print(string name)
        {
            return name;
        }

        private static string Write(string name)
        {
            return name;
        }

 

2.3 匿名方法

     2.2中的代碼賦給委托的方法都是 “具名方法”，可以重復使用的，如果賦給委托的方法只需要調用一次呢？定一個方法是不是太浪費了呢，

那匿名方法就出場了，什么是匿名方法我就不解釋了，看名字就知道了。寫一寫使匿名方法的注意點：

1  必須要有 delegate類型關鍵字，

2  必須要與委托的參數返回值匹配

好了上代碼 

//聲明委托 
public delegate int DelegateDemos(int x);

// 把匿名方法賦給委托，參數，與返回值都必須一樣，還要有delegate關鍵字
 DelegateDemos dele3 = delegate(int x) { return x + 20; };

 //調用委托
  dele3(20)//返回40

有了匿名方法后是不是感覺方便清爽很多呢 不用再去定義一個方法了少了很多代碼。

那 delegate(int x) { return x + 20; }; 這段代碼能否再簡化一點呢，那是肯定的 這個時候就要引入 "Lambda"表達示了 “=>”

有了lambda表達示后可以將匿名方法轉換為lambda表達示寫法

            DelegateDemos dele3 = delegate(int x) { return x + 20; };//匿名方法
            DelegateDemos dele4 = (int x) => { return x + 20; };//lambda表達示
            //編譯器還可以從委托的 中聲明中知道委托參數的類型因此可以省略參數類型
            DelegateDemos dele4 = (x) => { return x + 20; };
            //如果只有一個隱式類型參數，我們可以省略周圍的圓括號
            DelegateDemos dele4 = x => { return x + 20; };
            //lambda表達式表達式的主體是語句塊或表達式，如果語句塊包含了一個返回語句
            //可以將語句塊，替換為return關鍵字后的表達式
            DelegateDemos dele4 = x => x + 20;

關於Lambda表達 式的參數列表的要點如下

1 lambda表達式的參數列表 中的參數必須在參數數量，類型和位置上與委托 相匹配。

2 表達 式的參數列表中的參數不一定需要包含類型(比如隱式類型)，除非委托 有ref 或out 參數這時類型是必須的

3 如果只有一個參數，並且是隱式類型的周圍的圓括號就可以省略，否則就是必須的

4 如果沒有參數，必須使用一組空括號

 

三 .net Freamwork定義的委托

3.1  Action泛型委托 

       Action是沒有返回值的泛型委托，可以有0-16個參數

   

    internal class ActionDelegate
    {
        public void ActionMethod(int x)
        {
            Console.WriteLine(x + 20);
        }
    }

    ActionDelegate actionDelegate = new ActionDelegate();
    //接收0-16個參數 沒有返回值
    Action<int> action = actionDelegate.ActionMethod;
    //綁定多個方法時要用 “+=”
    action += x => Console.WriteLine(x + 20);//匿名方法
    //調用時只要調用一次即可，會按綁定順序來執行綁定的方法 
    action(30);

 

 

 3.2  Func 委托 

　　可以有0-16個參數，但是返回類型是必須要的 如0個參數的Func委托 ：Func<TResult> func  這里的TResult指得就是返回類型

    internal class FuncDelegate
    {
        public int FuncMethod(int x)
        {
            Console.WriteLine(x);
            return x;
        }
    }
     FuncDelegate funcDelegate = new FuncDelegate();

     //接收0-16個參數 最后一個參數為返回值
     Func<int, int> func = funcDelegate.FuncMethod;

     func +=  x =>  x + 20; //匿名方法
            
     int result =func(20);//接收返回值
     Console.WriteLine(result);

 

 3.3  Predicate委托

　　Predicate只有一個參數，且返回值為bool類型

    internal class PredicateDelegate
    {
        public bool PredicateMethod(int x )
        {
            return x > 50;
        }
    }
     PredicateDelegate predicateDelegate = new PredicateDelegate();
      // 只有一個參數 並返回bool 值
     Predicate<int> predicate = predicateDelegate.PredicateMethod;

     predicate += x =>  x > 50; //匿名方法
            
     bool results =predicate(60);
     Console.WriteLine(results);

 

四  委托綜合應用

 

    internal class PeopleInfo
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public int Age { get; set; }
    }


            var peopleList = new List<PeopleInfo>();
            peopleList.Add(new PeopleInfo() { Id = 1, Name = "Zery", Age = 20 });
            peopleList.Add(new PeopleInfo() { Id = 2, Name = "Zhang", Age = 25 });
            /*==============Action 委托===================*/
            //自定義委托
            peopleList.ForEach(delegate(PeopleInfo x) { Console.WriteLine("姓名:{0} 年齡:{1}", x.Name, x.Age); });
            
            //Action 委托
            Action<PeopleInfo> action = x => Console.WriteLine("姓名:{0} 年齡:{1}", x.Name, x.Age);
            peopleList.ForEach(action);
            
            //Lambda表達示
            peopleList.ForEach(o=> Console.WriteLine("姓名:{0} 年齡:{1}",o.Name,o.Age));

            //全部輸出： 姓名:Zery 年齡:20
            //         姓名:Zhang 年齡:25   

            /*==============Func 委托=====================*/
            //自定義委托
            var deleFValue = peopleList.Where(delegate(PeopleInfo x) { return x.Name == "Zery"; });
            Console.WriteLine(deleFValue.FirstOrDefault().Name);

            //Func 委托
            Func<PeopleInfo, bool> func = x => x.Name=="Zery";
            var funcFValue = peopleList.Where(func);
            Console.WriteLine(funcFValue.FirstOrDefault().Name);

            //Lambda表達示
            var lamaFValue = peopleList.Where(o => o.Name == "Zery");
            Console.WriteLine(lamaFValue.FirstOrDefault().Name);

            //全部輸出："Zery"
             

            /*==============Predicate 委托================*/
            //自定義委托
            var delePValue = peopleList.Find(delegate(PeopleInfo x) { return x.Age == 25; });
            Console.WriteLine(delePValue.Name);

            //Predicate 委托 
            Predicate<PeopleInfo> predicate = x => x.Age == 25;
            var preValue = peopleList.Find(predicate);
            Console.WriteLine(preValue.Name);

            //Lambda表達示
            var lamPValue = peopleList.Find(o=> o.Age==25);
            Console.WriteLine(lamPValue.Name);

            //全部輸出："Zhang"

 

五 總結

　　　　當寫完這篇文章時，對委托的理解有了一個較為全面的了解，掃去了自己的又一個盲區，成長的過程是緩慢的，關鍵在於堅持。

 

    如果您覺得本文有給您帶來一點收獲，不妨點個推薦，為我的付出支持一下，謝謝~

    如果希望在技術的道路上能有更多的朋友，那就關注下我吧，讓我們一起在技術的路上奔跑

 

成長在於積累