C#委托与事件 - 技术栈

委托

委托相当于一个list链表，把被委托的函数或者方法都连在一个链表中；

被委托的函数有一个特征：大家都有同样的返回值类型和参数类型；

为什么委托可以定一个委托对象：可以理解为委托是一个类型，即

delegate void f(int c);

f a;//定了一个委托对象委托对象实例化就相当于点燃了这个爆竹，被委托的函数都会运行，但只输出最后一个值；

cs 复制代码

using System;

namespace cs1
{
    
    class Program
    {
        public delegate int Callback(int x);
        static Callback c;
        static int Dou(int x)
        {
            return x * 2;
        }
        static int Mul(int x)
        {
            return x * x;
        }
        static void Main(string[] args)
        {
           
            Callback c = Dou;
            c += Mul;
            Console.WriteLine(c(4));
            Console.ReadLine();
        }
    }
}

输出16，可见虽然只输出最后一个值，但是进去的x经历了Dou和Mul，即会依次执行被委托的函数，这就是一个"点燃一个炮竹"的感觉；

要想看到这个"链表"中每一个函数方法执行的值，可以用这个foreach

cs 复制代码

using System;

namespace cs1
{
    
    class Program
    {
        public delegate int Callback(int x);
        static Callback c;
        static int Dou(int x)
        {
            return x * 2;
        }
        static int Mul(int x)
        {
            return x * x;
        }
        static void Main(string[] args)
        {
           
            Callback c = Dou;
            c += Mul;
            foreach (Delegate i in c.GetInvocationList())
            {
                Callback k = (Callback)i;
                Console.WriteLine(k(4));
            }
             //   Console.WriteLine(c(4));
            Console.ReadLine();
        }
    }
}

委托如何与方法联：

1）用类的：

cs 复制代码

using System;

namespace cs1
{
    public delegate int Callback(int x);//这里的public可以省略
    class Double
    {
        public int dou(int x)//这里的oublic必须要，不然访问不了，因为跟C++类一样就是不写有一定的保护级别
        {
            return x * 2;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Double d= new Double();//因为有类，因为要调其中的方法，故要搞一个对象
            Callback c = new Callback(d.dou);//委托的对象
            Console.WriteLine(c(4));//委托对象实例化就可以有值出现
        }
    }
}

2）不用类：

cs 复制代码

using System;

namespace cs1
{
    
    class Program
    {
        public delegate int Callback(int x);
        static Callback c;
        static int Dou(int x)
        {
            return x * 2;
        }

        static void Main(string[] args)
        {
           
            c += Dou;//Callback c = Dou;
            Console.WriteLine(c(4));
            Console.ReadLine();
        }
    }
}

可以用+=，-=来处理委托"链表"中的函数方法;

这里的static用法：

为了确保静态委托能够引用方法，这些方法也必须是静态的，除非希望通过类的实例来引用这些非静态方法（如例1））。由于此例中委托对象c是静态的，所以方法Dou也应该是静态的，以确保它们可以被静态委托c引用。

还有必须把这些东西，委托，函数方法，放进class program里，跟Main并排;

事件

就与类相关了，可以参考上面写的用类将委托与函数方法链接起来。

cs 复制代码

using System;

namespace cs1
{
    class Jiaf//甲方，给出委托事件
    {
        public delegate void Do();
        public event Do d;//委托事件对象
        public virtual void TriggerEvent()
        {
            d?.Invoke(); // 安全地调用事件，避免在事件为空时抛出异常  
        }
       public Jiaf() {
            Console.WriteLine("连接到甲方了");
        }
    }
    class Yif//乙方，执行委托事件
    {
        public void Y()
        {
            Console.WriteLine("连接到乙方了");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Jiaf j = new Jiaf();
            Yif y = new Yif();
            j.d += new Jiaf.Do(y.Y);
            j.TriggerEvent();//为了启动委托，gpt写的
            
            Console.ReadLine();
            
        }
    }
}

事件用到的一个例子，比如，博主发了动态，并且想给每个订阅者发送信息告知动态更新了，上面这个例子中，甲方就是博主，乙方是粉丝订阅者。（具体我不太清楚了qwq