C#中常见的系统内置委托用法详解(抄录)

Posted 2020-09-06

C#中常见的系统内置委托

---

Action类、Func类、Predicate<T>、Comparison<T>委托

• Action类的委托

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

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

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

4. 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类的委托

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

4. 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<T>委托

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

1. 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<T>委托

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

• 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
  }