[c#] 委托

自定义委托

定义委托，需要根据要引用的函数来定义委托。
范围值的类型和参数类型、个数、顺序都要一致。

        public static void Hello(string msg)
        {
            Console.WriteLine("你好我是委托" + msg);
        }

那么委托就可以定义为
定义方式：delegate + 返回值 + 委托名称 + （参数类型 参数名称…）

	delegate void HelloDelegate(string msg);

实例化：
委托是特殊的类，因此也需要初始化,括号里只需要填写函数名即可，不需要加()
不加括号是引用，加括号是调用。

	HelloDelegate helloDelegate = new HelloDelegate(Hello);

调用
调用委托，就是调用实例化委托的那个方法

            helloDelegate.Invoke(" not bad");

using System;

namespace DelegateTest
{
    class Program
    {
        static void Main(string[] args)
        {
            //委托是特殊的类，因此也需要初始化,括号里只需要填写函数名即可，不需要加()
            //不加括号是引用，加括号是调用。
            HelloDelegate helloDelegate = new HelloDelegate(Hello);

            //调用,Invoke函数里填写引用函数的参数
            helloDelegate.Invoke(" not bad");
        }
        public static void Hello(string msg)
        {
            Console.WriteLine("你好我是委托" + msg);
        }

    }
    // 定义委托，可以根据要引用的函数(函数的返回值、参数都与委托相同),定义委托
    delegate void HelloDelegate(string msg);
}

泛型委托

泛型：代码重用，可以写出通用代码

此时我们已经写了Int类型方法的委托，如果将类型变为double，需要重新写委托，此时便需要泛型委托，便可以代码重用。

using System;

namespace DelegateTest
{
    class Program
    {
        static void Main(string[] args)
        {
            AddDelegate addDelegate = new AddDelegate(AddInt);
            addDelegate(3, 4);//调用委托可以不写Invoke

        }
        public static void AddInt(int a,int b)
        {
            Console.WriteLine(a + b);
        }
        public static void AddDouble(double a,double b)
        {
            Console.WriteLine(a + b);
        }

    }
    delegate void AddDelegate(int a, int b);
}

那么委托可以改写成：

   delegate void AddDelegate<T>(T a, T b);

实例化：

            AddDelegate<double> addDelegate1 = new AddDelegate<double>(AddDouble);
            addDelegate1(3.14, 4.1);//调用委托可以不写Invoke
            AddDelegate<int> addDelegate2 = new AddDelegate<int>(AddInt);
            addDelegate2(3, 4);

预定义委托

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

因此我们就不需要再去写类似这样的委托类声明了。

    delegate void AddDelegate(int a, int b);

无返回值委托Action<>

.NET封装了最多16个输入参数的Action<>委托。
你直接实例化

        Action<string, int> action1 = new Action<string, int>(print);

        public static void print(string str,int a)
        {
            Console.WriteLine(str + a);
        }

声明的部分，.NET框架已经为我们声明好了

    	public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);

拥有返回值的泛型委托Func<>

.NET框架为我们封装了17Func<>委托

	Func<string, int> func1 = new Func<string, int>(print);

        public static int print(string str)
        {
            return 0;
        }

同理，声明部分由.NET框架封装

    public delegate TResult Func<in T, out TResult>(T arg);

Predicate委托

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

lambda

在我们的实例化委托时，还需要去单独定义个函数名，而事实上这个函数名完全没有必要。

使用了匿名方法的委托：

            Action<string> action = new Action<string>(delegate (string msg)
            {
                Console.WriteLine(msg);
            });
            action("泛型委托Action,使用了匿名方法");

我们还可以删去delegate ，添加个lambda运算符：

            Action<string> action2 = new Action<string>((string msg) =>
           {
               Console.WriteLine(msg);
           });
            action2("泛型委托Action,使用了lambda运算符");
          

如果只有一个参数一个语句，可以进一步简化

            Action<string> action3 = new Action<string>(msg =>Console.WriteLine(msg));
            action3("泛型委托Action,一个参数一个语句进一步简化");

            //无返回值 无参数
            Action action4 = new Action(() => Console.WriteLine("无返回值 无参数"));

            //有返回值 单条件语句
            Func<string> func1= new Func<string>(() => "无返回值 无参数");