在公共语言运行时(CLR)环境中系统为我们内置了一些常用的委托，包括Action类的委托、Func类的委托、Predicate<T>委托、Comparison<T>委托等等。以上这些委托的命名空间都是System，所属程序集都是 mscorlib.dll，今天我就来讲一讲这些委托的使用方法。

就像我们自己已定义好的一样，要实现某些功能，我们可以直接利用系统内置委托，实例化它们，而不必显式定义一个新委托并将命名方法分配给该委托。如：

public static void Test()        {            Console.WriteLine("Just For Test");        }        static void Main(string[] args)        {           Action a = new Action(Test); //直接实例化一个Action委托，不用自己再定义新委托           a();        }

只要了解了该系统内置委托是干什么的，传什么参数，返回什么值，大家就可以仿上述例子自行调用，不再赘述。下面是我对这四类委托的总结，并附有结合匿名方法与Lambda表达式的范例，两种方法实现的结果一样，大家可举一反三，灵活运用。

一、Action类的委托

1.Action委托 封装一个方法，该方法不具有参数并且不返回值

2.Action<T>委托 封装一个方法，该方法只有一个参数并且不返回值

3.Action<T1,T2>委托 封装一个方法，该方法具有两个参数并且不返回值

…… ……

17.Action<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>委托 封装一个方法，该方法具有16个参数并且不返回值

下面以Action<T>委托为例，示范如何使用Action类的委托，该类委托仅仅是参数个数上有区别而已。

static void Main(string[] args)        {　　　　　　　#region Action
     
      委托示例            //需求：打印出整型集合list的元素            List
      
        list = new List
       
        () { 1, 2, 3, 4, 5 };            //将匿名方法分配给 Action
        
          委托实例            Action
         
           concat1 = delegate(int i) { Console.WriteLine(i); };            list.ForEach(concat1);            //将 lambda 表达式分配给 Action
          
            委托实例 Action
           
             concat2 = (i => Console.WriteLine(i)); list.ForEach(concat2); Console.ReadKey();　　　　　　 #endregion }
           
          
         
        
       
      
     

总结：

Action类的委托最少可以传入0个参数，最多可以传入16个参数，参数类型皆为逆变，并且不返回值。

二、Func类的委托

1.Func(TResult)委托封装封装一个不具有参数但却返回 TResult 参数指定的类型值的方法

2.Func(T,TResult)委托 封装一个具有一个参数并返回 TResult 参数指定的类型值的方法

3.Func(T1,T2,TResult)委托 封装一个具有两个参数并返回 TResult 参数指定的类型值的方法

…… ……

17.Func<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,TResult>委托 封装一个方法，该方法具有16个参数，并返回TResult参数所指定的类型的值

下面以Func<T,TResult>委托为例，示范如何使用Func类的委托，该类委托仅仅是参数个数上有区别而已。

static void Main(string[] args)        {            #region Func
     
      委托示例            //需求：查找整型集合list中大于3的所有元素组成的新集合，并打印出集合元素            List
      
        list = new List
       
        () { 1, 2, 3, 4, 5 };            //将匿名方法分配给 Func
        
          委托实例            Func
         
           concat1 = delegate(int i) { return i > 3; };            var newlist1 = list.Where(concat1).ToList();            //将 Lambda 表达式分配给 Func
          
            委托实例 Func
           
             concat2 = i => i > 3; var newlist2 = list.Where(concat2).ToList(); newlist1.ForEach(i => Console.WriteLine(i.ToString())); newlist2.ForEach(i => Console.WriteLine(i.ToString())); Console.ReadKey(); #endregion }
           
          
         
        
       
      
     

总结：

Func类的委托最少可以传入输入泛型参数(in，逆变) 1个，最多可以传入输入泛型参数(in，逆变) 16个，传入的输出泛型参数(out，协变)有且只有一个，这个类型是此委托封装的方法的返回值类型。

三、Predicate<T>委托

表示定义一组条件并确定指定对象是否符合这些条件的方法

下面给出Predicate<T>委托的范例：

static void Main(string[] args)        {            #region  Predicate
     
      委托示例            //需求：查找整型集合list中大于3的所有元素组成的新集合，并打印出集合元素            List
      
        list = new List
       
        () { 1, 2, 3, 4, 5 };            //将匿名方法分配给 Predicate
        
          委托实例            Predicate
         
           concat1 = delegate(int i) { return i > 3; };            var newlist1 = list.FindAll(concat1);            //将 lambda 表达式分配给 Predicate
          
            委托实例 Predicate
           
             concat2 = (c => c > 3); var newlist2 = list.FindAll(concat2); newlist1.ForEach(i => Console.WriteLine(i)); newlist2.ForEach(i => Console.WriteLine(i)); 　　　　　　　Console.ReadKey(); #endregion }
           
          
         
        
       
      
     

 总结：

Predicate<T>委托封装一个方法，该方法传入一个类型参数，这个参数是指要比较的对象的类型，此类型参数是逆变，同时接收一个参数(该参数就是要按照由此委托表示的方法中定义的条件进行比较的对象，参数的类型就是传入的类型参数的类型)，该方法始终返回bool类型的值。如果该对象符合由此委托表示的方法中定义的条件，则为 true；否则为 false。

四、Comparison<T>委托

表示比较同一类型的两个对象的方法

下面给出Comparison<T>委托的范例：

static void Main(string[] args)        {            #region  Comparison
     
      委托示例            //需求：将整型集合list中的所有元素倒序排列打印出来            List
      
        list = new List
       
        () { 1, 2, 3, 4, 5 };            //将匿名方法分配给 Comparison
        
          委托实例            Comparison
         
           concat1 = delegate(int i, int j) { return j - i; };            //将 lambda 表达式分配给 Comparison
          
            委托实例 Comparison
           
             concat2 = (i, j) => j - i; list.Sort(concat1); list.ForEach(c => Console.WriteLine(c.ToString())); list.Sort(concat2); list.ForEach(c => Console.WriteLine(c.ToString())); 　　　　　　　Console.ReadKey(); #endregion }
           
          
         
        
       
      
     

 总结：

Comparison<T>委托封装一个方法，该方法传入一个类型参数，这个参数是指要比较的对象的类型，此类型参数是逆变，同时接收两个同类型的参数(这两个参数就是要比较的两个对象，参数的类型就是传入的类型参数的类型)，始终返回int类型的值，即一个有符号整数，指示 x 与 y 的相对值，如下表所示。

值	含义
小于0	x 小于y
0	x 等于y
大于0	x 大于y