.Net委托_ZenDei技術網路在線

委托聲明委托是一種可以指向方法的數據類型。聲明委托格式：delegate 返回值類型委托類型名(參數); 比如delegate void MyDelgate(int n); 委托實例創建委托類型對象格式：也可以寫成簡化形式： //編譯器會自動搞成new Mydel (SayHello);註 ...

委托在開發過程中會經常使用的技術，啥？不知道，看看func和action，是不是覺得眼熟，這個就是.net framework內置的泛型委托，可以解決開發中的大多數問題，不需要再自定義委托了。

OK，下麵開始委托的介紹。

委托聲明

委托是一種可以指向方法的數據類型。

聲明委托格式：delegate 返回值類型委托類型名(參數);

比如delegate void MyDelgate(int n);

委托實例

class Program
    {
        delegate void MyDel(string name);//聲明委托
        static void Main(string[] args)
        {
            //委托將要指向的方法必須的參數個數、類型和返回值類型都必須要與委托聲明的一樣
            MyDel myDel = new MyDel(SayHello);//這裡不要寫成SayHello()
            myDel("蛋蛋");//輸出"蛋蛋你好"
            myDel = null;
            myDel("蛋蛋");//會拋出空引用異常
            Console.ReadKey();
        }
        static void SayHello(string name)
        {
            Console.WriteLine(name + "你好！");
        }
    }
}

創建委托類型對象格式：

MyDelgate myDel = new MyDelgate(方法名)；

也可以寫成簡化形式：

MyDelgate myDel = 方法名；

//編譯器會自動搞成new Mydel (SayHello);註意方法名不能帶括弧

在寫一個例子，獲取一個數組中最大值；由於類型不定，所以最大值的演算法也不一樣，可以使用委托把最大演算法穩定下來，把比較規則通過委托進行開放。

class Program
    {
        delegate bool CompareNum(object obj1, object obj2);
        static void Main(string[] args)
        {
            object[] objs = { 1, 2, 4, 4, 2, 1, 2, 3 };
            //通過這樣寫，獲取最大值的演算法已經確定，在傳參數的是後指定上比較方法就好了
            //用委托後，我們不在為每個獲取最大值的方法都去寫一種演算法
            int max=(int)GetMax(objs, CompareInt);//原生的寫法為GetMax(objs,new CompareNum(CompareInt));//只不過編譯器幫我們進行了處理
            Console.WriteLine(max);
            Console.ReadKey();
        }
        //int比較方法，與委托參數一致
        static bool CompareInt(object obj1, object obj2)
        {
            int i1 = (int)obj1;
            int i2 = (int)obj2;
            return i1 > i2;
        }
        //獲取最大值，將要比較的參數和比較使用的方法名傳入，返回最大值
        static object GetMax(object[] obj, CompareNum cpn)
        {
            object max = obj[0];
            for (int i = 1; i < obj.Length; i++)
            {
                if (!cpn(max, obj[i]))
                {
                    max = obj[i];
                }
            }
            return max;
        }
    }

同樣我們可以在寫一個方法，用來比較float類型數組,使用方法和上面int類型的一樣，例如

　　　　 //float比較方法，與委托參數一致
        static bool CompareFloat(object obj1, object obj2)
        {
            float f1 = (float)obj1;
            float f2 = (float)obj2;
            return f1 > f2;
        }

調用格式是：

float max=(float)GetMax(objs, CompareFloat);

Func、Action內置泛型委托

這個兩個內置的泛型委托在micorlib的 System 下，使用這倆委托，日常開發基本不用自定義委托類型；

首先我們先看他們的定義：

1、Func是有返回值的委托；

2、Action是沒有返回值的委托

使用這個兩個委托重寫上面代碼如下：

 class Program
    {
        static void Main(string[] args)
        {
            Action<string> ac = new Action<string>(Greeting);//沒有返回值的內置委托
            ac("蛋蛋");
            Func<string, string> fu = new Func<string, string>(GreetingForR);//有返回值的內置委托
            string msg = fu("建國");
            Console.WriteLine(msg);
            Console.ReadKey();
        }
        static string GreetingForR(string name)
        {
            return name + "你好";
        }
        static void Greeting(string name)
        {
            Console.WriteLine(name + "你好");
        }
    }

效果顯示如下，這裡的ac("李誕")是不能賦值給其他變數的，因為它是沒有返回值的void類型，註意也可以寫成下麵的簡寫形式，使用這兩個內置委托，可以使我們的開發過程很方便。慢慢大家會感受到它們的好處。

匿名方法

使用Delegate的時候很多時候沒必要使用一個普通的方法，因為這個方法只有這個Delegate會用，並且只用一次，這時候使用匿名方法最合適。

匿名方法就是沒有名字的方法，格式：MyDelegate p = delegate(int s){s=10;};

例如改造getMax代碼

class Program
    {
        delegate bool CompareNum(object obj1, object obj2);
        static void Main(string[] args)
        {

            object[] objs = { 1, 2, 4, 4, 2, 1, 2, 3 };
            //通過這樣寫，獲取最大值的演算法已經確定，在傳參數的是後指定上比較方法就好了
            //用委托後，我們不在為每個獲取最大值的方法都去寫一種演算法
           
　　　　　　　 CompareNum cpn = delegate (object obj1, object obj2)
            {
                int i1 = (int)obj1;
                int i2 = (int)obj2;
                return i1 > i2;
            };
            //int max=(int)GetMax(objs, CompareInt);//原生的寫法為GetMax(objs,new CompareNum(CompareInt));//只不過編譯器幫我們進行了處理
            int max = (int)GetMax(objs, cpn);//使用匿名方法
            Console.WriteLine(max);
            Console.ReadKey();
        }
        static bool CompareInt(object obj1, object obj2)
        {
            int i1 = (int)obj1;
            int i2 = (int)obj2;
            return i1 > i2;
        }
        static object GetMax(object[] obj, CompareNum cpn)
        {
            object max = obj[0];
            for (int i = 1; i < obj.Length; i++)
            {
                if (!cpn(max, obj[i]))
                {
                    max = obj[i];
                }
            }
            return max;
        }
    }

委托和lambda表達式

lambda是一種比匿名方法更加簡潔的匿名方法

①Lambda表達式中的參數列表（參數數量、類型和位置）必須與委托相匹配；

②表達式中的參數列表不一定需要包含類型，除非委托有ref或out關鍵字（此時必須顯示聲明）；

③如果沒有參數，必須使用一組空的圓括弧；

class Program
    {
        delegate bool CompareNum(object obj1, object obj2);
        static void Main(string[] args)
        {
            //1、匿名方法
            Action<string, bool> a1 = delegate (string s, bool b) {
                if (b) { Console.WriteLine("true" + s); }
                else { Console.WriteLine("false" + s); }
            };
            //2、簡化後
            Action<string, bool> a2 = (s, b) =>
            {
                if (b) { Console.WriteLine("true" + s); }
                else { Console.WriteLine("false" + s); }
            };
            a2("hello", true);

            //1、匿名方法
            Func<string, int> f1 = delegate (string str) { return Convert.ToInt32(str); };
            //2、簡化後
            Func<string, int> f2 = (str) => Convert.ToInt32(str); ;
            int i = f2("1");

            Console.WriteLine(i);
            Console.ReadKey();
        }
   }

在看一些例子說明一下委托匿名方法和lambda表達式的轉換

　　　　　　　　//1、
            Action<string, int> a11 = (s1, i1) => { Console.WriteLine("s1=" + s1 + ",i1=" + i1); };
            //還原後
            Action<string, int> a12 = delegate (string s1, int i1) {  Console.WriteLine("s1=" + s1 + ",i1=" + i1); };
            //2、
            Func<int, string> f11 = n => (n + 1).ToString();
            //還原後
            Func<int, string> f12 = delegate (int n) { return (n + 1).ToString(); };
            //3、
            Func<int, int> f13 = n => n * 2;
            //還原後
            Func<int, int> f14 = delegate (int n) { return n * 2; };

寫出下麵一個lambda表達式的委托類型及非匿名函數格式

class Program
    {
        static void Main(string[] args)
        {

            //Func<int, bool> f15 =n=>n>0;
            Func<int, bool> f15 = delegate (int n) { return n > 0; };
            Func<int, bool> f16 = IsDYl;
            bool i=f16(-1);
            Console.WriteLine(i);
            Console.ReadKey();
        }
        static bool IsDYl(int n)
        {
            return n > 0;
        }
    }

使用lambda調用之前的GetMax

class Program
    {
        static void Main(string[] args)
        {
            object[] objs = { 1, 2, 4, 4, 2, 1, 2, 3 };
            Func<object, object, bool> cpn = (obj1, obj2) =>
              {
                  int i1 = (int)obj1;
                  int i2 = (int)obj2;
                  return i1 > i2;
              };
            int max = (int)GetMax(objs, cpn);//使用匿名方法
            Console.WriteLine(max);
            Console.ReadKey();
        }
        static bool CompareInt(object obj1, object obj2)
        {
            int i1 = (int)obj1;
            int i2 = (int)obj2;
            return i1 > i2;
        }
        static object GetMax(object[] obj, Func<object,object,bool> cpn)
        {
            object max = obj[0];
            for (int i = 1; i < obj.Length; i++)
            {
                if (!cpn(max, obj[i]))
                {
                    max = obj[i];
                }
            }
            return max;
        }
    }

委托深入

集合常用擴展方法：

Where（支持委托）、Select（支持委托）、Max、Min、OrderBy

First（獲取第一個，如果一個都沒有則異常）

FirstOrDefault（獲取第一個，如果一個都沒有則返回預設值）

Single （獲取唯一一個，如果沒有或者有多個則異常）

SingleOrDefault （獲取唯一一個，如果沒有則返回預設值，如果有多個則異常）

這些都是集合常用的方法

委托的組合

委托對象可以“+相加”，調用組合後的新委托對象會依次調用被組合起來的委托：MyDel m5 = m1+m2+m3;

組合的委托必須是同一個委托類型

(*)委托的“-”則是從組合委托中把委托移除；

(*)委托如果有返回值，則有一些特殊。委托的組合一般是給事件用的，用普通的委托的時候很少用

class Program
    {
        delegate void MyDel();
        static void Main(string[] args)
        {
            MyDel myDel = del1;
            myDel += del2;
            myDel();
            myDel -= del1;
            myDel();
            Console.ReadKey();
        }
       static void del1()
        {
            Console.WriteLine("第1個委托");
        }
        static void del2()
        {
            Console.WriteLine("第2個委托");
        }
    }