美文网首页
C#内置泛型委托

C#内置泛型委托

作者: ottox | 来源:发表于2018-11-13 21:53 被阅读11次

    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

    相关文章

      网友评论

          本文标题:C#内置泛型委托

          本文链接:https://www.haomeiwen.com/subject/avrrfqtx.html