委托类型 (delegate type) 表示对具有特定参数列表和返回类型的方法的引用。通过委托，我们能够将方法作为实体赋值给变量和作为参数传递。委托类似于在其他某些语言中的函数指针的概念，但是与函数指针不同，委托是面向对象的，并且是类型安全的。

    将一个方法作为参数传递给另一个方法。
    委托所指向的函数必须跟委托具有相同的签名。（参数和返回值类型 ）

    1. using System;
    3. namespace _143_委托引入
    4. {
    5.     public delegate void DelSayHi(string name);
    6.     class Program
    7.     {
    8.         static void Main(string[] args)
    9.         {
    10.             DelSayHi del = SayHiChinese;  // new DelSayHi(SayHiChinese);
    11.             del("微咲");
    13.             Test("wexiao", SayHiEnglish);
    15.             //匿名函数
    16.             DelSayHi ndel = 
    17.                 delegate (string name) 
    18.                 { 
    19.                     Console.WriteLine("我是匿名函数" + name); 
    20.                 };
    21.             ndel("hello one");
    23.             //lambda表达式  =>  goes to      ;;;;;;;;;;
    24.             DelSayHi ndel2 = (string name) => { Console.WriteLine(name + "lambda表达式"); };
    25.             ndel2("lambda");
    27.             Console.ReadKey();
    28.         }
    30.         public static void Test(string name, DelSayHi del)
    31.         {
    32.             //调用
    33.             del(name);
    34.         }
    36.         public static void SayHiChinese(string name)
    37.         {
    38.             Console.WriteLine("你好" + name);
    39.         }
    40.         public static void SayHiEnglish(string name)
    41.         {
    42.             Console.WriteLine("Hello" + name);
    43.         }
    44.     }
    45. }
    1. using System;
    3. namespace _142_为什么使用委托
    4. {
    5.     public delegate string DelProStr(string name);
    7.     class Program
    8.     {
    9.         static void Main(string[] args)
    10.         {
    11.             string[] names = { "aBcDEFg", "HijKLmNOPq", "RxYZ" };
    13.             //ProStrToUpper(names);
    14.             //roStrSYH(names);
    16.             ProStr(names, ProStrToLower);
    19.             //匿名函数
    20.             ProStr(names, delegate (string name)
    21.              {
    22.                  return name.ToUpper();
    23.              }
    24.             );
    26.             for (int i = 0; i < names.Length; i++)
    27.             {
    28.                 Console.WriteLine(names[i]);
    29.             }
    30.             Console.ReadKey();
    31.         }
    33.         //将一个方法作为参数传入方法==委托
    35.         public static void ProStr(string[] names,DelProStr del)
    36.         {
    37.             for (int i = 0; i < names.Length; i++)
    38.             {
    39.                 names[i] = del(names[i]);
    40.             }
    41.         }
    42.         public static string ProStrToUpper(string name)
    43.         {
    44.             return name.ToUpper();
    45.         }
    46.         public static string ProStrToLower(string name)
    47.         {
    48.             return name.ToLower(); 
    49.         }
    50.         public static string ProStrSYH(string name)
    51.         {
    52.             return "\"" + name + "\"";
    53.         }
    56.         //public static void ProStrToUpper(string[] names)
    57.         //{
    58.         //    for (int i = 0; i < names.Length; i++)
    59.         //    {
    60.         //        names[i] = names[i].ToUpper();
    61.         //    }
    62.         //}
    64.         //public static void ProStrToLower(string[] names)
    65.         //{
    66.         //    for (int i = 0; i < names.Length; i++)
    67.         //    {
    68.         //        names[i] = names[i].ToLower();
    69.         //    }
    70.         //}
    72.         //public static void ProStrSYH(string[] names)
    73.         //{
    74.         //    for (int i = 0; i < names.Length; i++)
    75.         //    {
    76.         //        names[i] = "\"" + names[i] + "\"";
    77.         //    }
    78.         //}
    79.     }
    80. }

    委托练习：
    求任意数组的最大值

    1. using System;
    3. namespace _144_使用委托求任意数组最大值
    4. {
    5.     //声明一个委托：比较o1与o2大小
    6.     public delegate int DelCompare(object o1, object o2);
    7.     class Program
    8.     {
    9.         static void Main(string[] args)
    10.         {
    11.             object[] o = { 1, 2, 3, 4, 5 };
    12.             object result = GetMax(o, CompareInt);
    13.             Console.WriteLine(result);
    15.             object[] o1 = { "dwadawd", "dwaudhwauf", "我是你亲爱的老父亲咿呀咿呀哟咿呀咿呀哟", "wduhwauifgauibgysahjdn" };
    16.             result = GetMax(o1, CompareString);
    17.             Console.WriteLine(result);
    19.             Console.ReadKey();
    20.         }
    22.         /// <summary>
    23.         /// 求数组最大值
    24.         /// </summary>
    25.         /// <param name="nums">要求最大值的数组</param>
    26.         /// <param name="del">比较最大值和数组元素的委托</param>
    27.         /// <returns>最大值</returns>
    28.         public static object GetMax(object[] nums, DelCompare del)
    29.         {
    30.             object max = nums[0];
    31.             for (int i = 0; i < nums.Length; i++)
    32.             {
    33.                 //要传一个比较的方法,   如果max<nums[i]就会执行if
    34.                 if (del(max, nums[i]) < 0)
    35.                 {
    36.                     max = nums[i];
    37.                 }
    38.             }
    39.             return max;
    40.         }
    42.         /// <summary>
    43.         /// 比较int型数据的大小
    44.         /// </summary>
    45.         /// <param name="o1"></param>
    46.         /// <param name="o2"></param>
    47.         /// <returns></returns>
    48.         public static int CompareInt(object o1, object o2)
    49.         {
    50.             int n1 = (int)o1;
    51.             int n2 = (int)o2;
    52.             return n1 - n2;
    53.         }
    55.         /// <summary>
    56.         /// 比较string型数据的大小
    57.         /// </summary>
    58.         /// <param name="o1"></param>
    59.         /// <param name="o2"></param>
    60.         /// <returns></returns>
    61.         public static int CompareString(object o1, object o2)
    62.         {
    63.             string s1 = (string)o1;
    64.             string s2 = (string)o2;
    65.             return s1.Length - s2.Length;
    66.         }
    67.     }
    68. }

    使用泛型委托求任意数组的最大值

    1. using System;
    3. namespace _145_泛型委托求数组最大值
    4. {
    5.     //声明一个委托：比较o1与o2大小
    6.     public delegate int DelCompare<T>(T t1,T t2);
    7.     //public delegate int DelCompare(object o1, object o2);
    8.     class Program
    9.     {
    10.         static void Main(string[] args)
    11.         {
    12.             int[] nums = { 1, 2, 3, 4, 5, 6, 7 };
    13.             int max= GetMax<int>(nums, CompareInt);
    14.             Console.WriteLine(max);
    16.             string[] names = { "微咲", "我是你爹", "sduahwuifhwauibfwabndhwabdywaubfy" };
    17.             string maxLenth = GetMax<string>(names, CompareString);
    18.             Console.WriteLine(maxLenth);
    20.             Console.ReadKey();
    21.         }
    22.         /// <summary>
    23.         /// 求数组最大值
    24.         /// </summary>
    25.         /// <param name="nums">要求最大值的数组</param>
    26.         /// <param name="del">比较最大值和数组元素的委托</param>
    27.         /// <returns>最大值</returns>
    28.         public static T GetMax<T>(T[] nums, DelCompare<T> del)
    29.         {
    30.             T max = nums[0];
    31.             for (int i = 0; i < nums.Length; i++)
    32.             {
    33.                 //要传一个比较的方法,   如果max<nums[i]就会执行if
    34.                 if (del(max, nums[i]) < 0)
    35.                 {
    36.                     max = nums[i];
    37.                 }
    38.             }
    39.             return max;
    40.         }
    42.         /// <summary>
    43.         /// 比较int型数据的大小
    44.         /// </summary>
    45.         /// <param name="n1"></param>
    46.         /// <param name="n2"></param>
    47.         /// <returns></returns>
    48.         public static int CompareInt(int n1, int n2)
    49.         {
    50.             return n1 - n2;
    51.         }
    53.         /// <summary>
    54.         /// 比较string型数据的大小
    55.         /// </summary>
    56.         /// <param name="s1"></param>
    57.         /// <param name="s2"></param>
    58.         /// <returns></returns>
    59.         public static int CompareString(string s1, string s2)
    60.         {
    61.             return s1.Length - s2.Length;
    62.         }
    63.     }
    64. }