泛型委托

泛型委托

简介：

我们每次要使用一个委托时，都需要先声明这个委托类，规定参数和返回值类型，然后才能实例化、调用。为了简化这个过程， .NET 框架为我们封装了三个泛型委托类，因此大部分情况下我们不必再声明委托，可以拿来直接实例化使用，方便了我们的日常Coding。

这三种泛型委托包括：Func<T>委托、Action<T>委托和Predicate<T>委托。

一、泛型委托之Action<>

泛型委托代表返回值为空 void 的委托，它也有一些列重载，最多拥有16个输入参数。

案例一：

 

//泛型委托之Action，最多可传入16个参数
    class Program
    {
        //1.定义泛型
        //传入一个参数的方法
        public static void TestAction<T>(Action<T> action, T p1)
        {
            //Action传入一个参数测试
            action(p1);
        }

        //传入两个参数的方法
        public static void TestAction<T, P>(Action<T, P> action, T p1, P p2)
        {
            //Action传入两个参数测试
            action(p1, p2);
        }


        //2.定义委托引用的方法
        public static void getString(string a)
        {
            //实现int类型打印
            Console.WriteLine("测试Action，传入string，并且传入的参数为：" + a);
        }
        public static void getInt(int a)
        {
            //实现String类型打印
            Console.WriteLine("测试Action，传入int，并且传入的参数为：" + a);
        }
        public static void getStringAndInt(int a, string name)
        {
            //实现int+string类型打印
            Console.WriteLine("测试Action，传入int和string，并且传入的参数为：" + a + ":" + name);
        }

        static void Main(string[] args)
        {
            //3.泛型实例化
            TestAction<string>(getString, "WhiteTaken"); //方法引用和传入参数
            TestAction<int>(getInt, 666);
            TestAction<int, string>(getStringAndInt, 666, "WhiteTaken");
            Console.Read();
        }

    }

 

 

 

二、泛型委托之Func<>

Func<T>委托代表着拥有返回值的泛型委托。Func<T>有一系列的重载，形式如 Func<T1,T2, ... TResult>，其中TResult代表委托的返回值类型，其余均是参数类型。只有一个T时，即Func<TResult>，代表该委托是无参数的。.NET封装了最多16个输入参数的Funct<>委托。

案例一：

 class Program
    {
        public class SumClass
        {
            //1.定义的Func<>泛型委托引用的方法，必须有返回值和2个参数的
            static int add(int a, int b)
            {

                return a * b;
            }
            static void Main(string[] args)
            {
                int sum = 0;
                //2.使用.NET原生Func<>泛型委托来接收方法，前2个int表示有2个参数，后面的int表示返回int类型
                Func<int, int, int> my = add;
                //int变量Sum来接收委托，利用反射中的Invoke进行援引赋值
                sum = my.Invoke(10, 10);
                Console.WriteLine(sum);
                Console.ReadKey();
            }
           
        }
    }

案例二：

 class Program
    {
        public class FuncTest
        {
            //1.利用.NET 的原生方法定义泛型委托
            public static R TestFunc<T1, T2, T3, T4, R>(Func<T1, T2, T3, T4, R> Func, T1 t1, T2 t2, T3 t3, T4 t4)
            {
                return Func(t1, t2, t3, t4);
            }

           //2.定义泛型委托方法的引用
            public static int add(int a, int b, int c, int d)
            {
                return (a + b + c + d);
            }

            public static int returnInt(int a, int b, int c, string d)
            {
                //返回加和
                return a + b + c + int.Parse(d);
            }

            static void Main(string[] args)
            {
                //3.实例化调用
                int sum = 0;
                //使用系统Func<>委托来接收方法，前4个int表示有4个参数，后面的int表示返回int类型
                Func<int, int, int, int, int> tf = add;
                sum = tf.Invoke(10,10 ,10,10);
                Console.WriteLine(sum);
                //泛型委托实例化以及传参绑定
                sum = TestFunc<int,int,int,string ,int>(returnInt, 1, 2, 3, "4"); //传入方法
                Console.ReadKey();
            }

        }
    }

 

三、泛型委托之Predicate<>

Predicate<T>一般用的较少，它封装返回值为bool类型的委托，可被Func<T>代替。

案例：