C#委托应用

c#程序设计–委托（delegate）应用

什么是委托？

委托是一种存储函数的引用类型。委托的声明非常类似于函数，但不带函数体，且要使用delegate关键字。委托的声明指定了一个返回类型和一个参数列表。
定义了委托后，就可以声明该委托类型的变量。接着把这个变量初始化为于委托具有相同返回类型和参数列表的引用。之后，就可以使用委托变量调用这个函数，就像该变量是一个函数一样。

委托申明

委托声明后决定了该委托可以引用的方法。

public delegate int processDelegate(int num1);
上面声明的委托可以用于引用任何返回值为string类型并且参数为一个int类型的任意方法名的方法,例如：public static int add(int num2){return num2};

初始化委托变量以及赋值

委托申明后还需要对委托变量进行初始化才能使用，常见的初始化及赋值方式有：
1、new实例化赋值

processDelegate processdelegate = new processDelegate();

2、直接赋值

processDelegate processdelegate = add;//由于add函数为static静态函数，所以可以直接调用。对于非静态方法还需要实例化相对应的类。例如：
processDelegate processdelegate = new person().add;

关于委托对象的自增自减运算

委托对象可以通过 ‘+’ 运算法进行组合，一个合并委托调用所组合的委托的所有指向方法引用地址，合并的委托必须是相同类型的。不仅是对象可以组合，通过 ‘+’ 运算符可以让委托变量对方法自增。

processDelegate processdelegate = add;
processdelegate+=add2；//add2为另一委托函数

有增自然有减，可以通过 ‘-’ 运算符进行方法引用地址的剔除，如果有多个同样的方法，只删除其中一个。

委托实验

有下面两个类，代表电视和电灯。定义委托类型，生成委托实例，在Program类的Main函数中，同时打开电视和电灯，再同时关闭它们。

class TV
    {
        public void on(int channel)
        {
            Console.WriteLine("电视已打开，在看" + channel + "频道");
        }
        public void off()
        {
            Console.WriteLine("电视已关闭");
        }
    }
    class LEDLight
    {
        static bool[] light = new bool[5];
        public static void turnon(int no)
        {
            if(no >= 1 && no <= 5)
            {
                light[no-1] = true;
                Console.WriteLine("已经开了" + no + "号灯");
            }
        }
        public static void turnoff()
        {
            for(int i=0; i<5; i++)
                light[i] = false;
            Console.WriteLine("电灯已全部关闭");
        }
    }

源代码

 class Program
    {
        delegate void onDelegate(int num);
        delegate void offDelegate();
        static void Main(string[] args)
        {
            //实例化类
            delegateController controller = new delegateController();
            TV tv = new TV();
            LEDLight light = new LEDLight();
            //添加委托对象
            controller.inStance(tv.on, tv.off);
            controller.inStance(LEDLight.turnon, LEDLight.turnoff);//静态方法通过类名调用
            //调用委托
            Random rd = new Random();
            controller.trunOn(rd.Next(1,5));
            controller.trunOff();
        }
    }

    class TV
    {
        public void on(int channel)
        {
            Console.WriteLine("电视已打开，在看" + channel + "频道");
        }
        public void off()
        {
            Console.WriteLine("电视已关闭");
        }
    }
    class LEDLight
    {
        static bool[] light = new bool[5];
        public static void turnon(int no)
        {
            if (no >= 1 && no <= 5)
            {
                light[no - 1] = true;
                Console.WriteLine("已经开了" + no + "号灯");
            }
        }
        public static void turnoff()
        {
            for (int i = 0; i < 5; i++)
                light[i] = false;
            Console.WriteLine("电灯已全部关闭");
        }
    }

    class delegateController
    {
        public delegateController() { }//定义构造函数

        public delegate void onDelegate(int num);//定义委托类型onDelegate，委托的返回值和参数要和委托函数一致
        
        public delegate void offDelegate();//定义委托类型offDelegate，委托的返回值和参数要和委托函数一致

        //声明委托类型的对象
        public onDelegate ondelegate;
        public offDelegate offdelegate;

        public void inStance(onDelegate ondelegate, offDelegate offdelegate)//实例化委托对象
        {
            //委托对象自增
            this.ondelegate += ondelegate;
            this.offdelegate += offdelegate;
        }

        public void deleteInstance(onDelegate ondelegate, offDelegate offdelegate)//删除委托对象
        {
            //委托对象自减
            ondelegate -= ondelegate;
            offdelegate -= offdelegate;
        }

        public void trunOn(int num)//调用委托
        {
            ondelegate(num);
        }
        public void trunOff()//调用委托
        {
            offdelegate();
        }
    }

总结