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
