委托的说明

C#的委托,其实就是C#函数指针的升级版
直接调用,是我们通过函数名,来直接使用定义的函数(方法),而委托,就类似于你不直接去调用这个函数,也就是我不直接去做一件事情,而是委托给别人去做.
(Java语言禁止直接访问内存地址,Java语言舍弃了所有c/c++中的关于指针的功能)

委托的形式

委托有
Action 委托
Func 委托

Action案例

我们先看来一看Action委托

using System;

namespace DeleGate
{
    class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Action action = new Action(calculator.Report); //Action接收一个无返回值的target
            calculator.Report();//直接调用Report方法
            action.Invoke();//委托调用Report方法,也就是间接调用,这里的Invoke方法可以省去,写作action();
            action();//和上面的使用结果是一样的.

        }
    }
    class Calculator
    {
        public void Report()  //参数列表为空,无返回值写void
        {
            {
                Console.WriteLine("我有3个方法");
            }

        }
    }
}

Func案例

你看,Action,他能够处理的方法是返回值为void的方法,那比如现在我要将有返回值的函数(方法)进行委托呢?
那么就需要用到Func了,这是一个泛型委托,他有尖括号<>
比如:

    using System;

    namespace DeleGate
    {
        class Program
        {
            static void Main(string[] args)
            {
                Calculator calculator = new Calculator();
            Func<int, int, int> func1 = new Func<int, int, int>(calculator.Add); //最后一个int是返回类型,当你输入好尖括号后ide会提示你有多少重载方法可以使用
            int result;
            result = func1(1,2);//你看,这样可以用func来调用Add方法了.下面的func2使用了Invoke,而这里没用,是一样的
            Console.WriteLine(result);
            Func<int, int, int> func2 = new Func<int, int, int>(calculator.Sub);
            result = func2.Invoke(10, 1);//用Invoke和不用是一样的,习惯之后其实你会用的
            }
        }
        class Calculator
        {
            public  int Add(int a,int b)//返回值是int类型,参数列表也是2个int
            {
                int result = a + b;
                return result;
            }
            public int Sub(int a, int b)
            {
                int result = a - b;
                return result;
            }
        }
    }

自定义委托(自己声明委托)

委托是一种类(class),类是数据类型(引用类型的数据类型),所以委托也是一种数据类型,它的声明方式和一般的类不同,委托与它所封装的方法必须类型兼容.

类呢,它可以申明变量,可以创建实例.委托既然是一种类,那么委托也可以用来申明变量,创建实例.
输出 typeof(Action),就知道了,

t = typeof(Action);
console.WriteLine(t.Iscalss);
//结果为True

委托的定义

委托的定义和类有些不同,目的是为了照顾可读性和保持与c/c++传统的一致性
(仿造函数指针的申明格式)
申明在名称空间内,它与类是平级的(否则你将只能在该类内使用委托)
下面我们来看实例:

    using System;

    namespace DeleGate
    {
        public delegate double Calc(double a, double b); //申明一个自定义委托,公共 委托 double类型返回值 名称(参数);
        class Program
        {
            static void Main(string[] args)
        {
            Calculator calculator = new Calculator();//首先创建Calculator的实例
            Calc calc1 = new Calc(calculator.Add);//然后我们分别创建4个委托,对应4个方法(加减乘除)
            Calc calc2 = new Calc(calculator.Sub);
            Calc calc3 = new Calc(calculator.Mul);
            Calc calc4 = new Calc(calculator.Div);
            double a = 100;
            double b = 200;
            double result = 0;
            result = calc1.Invoke(a, b);//我们调用这4个方法,第一个用了Invoke,其他3个都不用,效果是一样的
            Console.WriteLine(result);
            result = calc2(a, b);
            Console.WriteLine(result);
            result = calc3(a, b);
            Console.WriteLine(result);
            result = calc4(a, b);
            Console.WriteLine(result);


        }
    }
        class Calculator
        {

            public double Add(double a, double b)
            {
            double result = a + b;
                return result;
            }
            public double Sub(double a, double b)
            {
            double result = a - b;
                return result;
            }
            public double Mul(double a,double b)
            {
            double result = a * b;
            return result;
            }
            public double Div(double a,double b)
            {
            double result = a / b;
            return result;
            }
        }
    }