C#内置泛型委托

Action

Action是无返回值的泛型委托。

Action 表示无参，无返回值的委托

Action<int,string> 表示有传入参数int,string无返回值的委托

Action<int,string,bool> 表示有传入参数int,string,bool无返回值的委托

Action<int,int,int,int> 表示有传入4个int型参数，无返回值的委托

Action至少0个参数，至多16个参数，无返回值。

public void Test<T>(Action<T> action,T p)
{
action(p);
}

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

Func

Func是有返回值的泛型委托

Func<int> 表示无参，返回值为int的委托

Func<object,string,int> 表示传入参数为object, string 返回值为int的委托

Func<object,string,int> 表示传入参数为object, string 返回值为int的委托

Func<T1,T2,,T3,int> 表示传入参数为T1,T2,,T3(泛型)返回值为int的委托

Func至少0个参数，至多16个参数，根据返回值泛型返回。必须有返回值，不可void

public int Test<T1,T2>(Func<T1,T2,int>func,T1 a,T2 b)
{
return func(a, b);
}

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

predicate

predicate 是返回bool型的泛型委托

predicate<int> 表示传入参数为int 返回bool的委托

Predicate有且只有一个参数，返回值固定为bool

public delegate bool Predicate<T> (T obj)

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

Comparison

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

public delegate int Comparison<T>(T x, T y);

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

总结：

Delegate至少0个参数，至多32个参数，可以无返回值，也可以指定返回值类型

Func可以接受0个至16个传入参数，必须具有返回值

Action可以接受0个至16个传入参数，无返回值

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

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

详细参考：http://www.cnblogs.com/akwwl/p/3232679.html
https://www.cnblogs.com/0weibin/p/3955207.html