Délégué C# + événement

1. Déléguer : équivalent à un pointeur de fonction, il s'agit essentiellement d'une classe qui peut être instanciée, et il existe des attributs de champ pointant vers des méthodes à l'intérieur de la classe.
Quant à savoir pourquoi la délégation est utilisée, je pense personnellement que cela améliore l'évolutivité du programme. Lorsque le programme est mis à jour, il n'est pas nécessaire de modifier considérablement la logique principale à l'intérieur du programme, et il suffit de développer la base d'origine.

commandé :

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DelegateTest
{
    internal class Program
    {
        //委托：将方法作为参数传递，而且方法的参数列表和返回值要与委托类型一致
        //无参无返回值的委托
        public delegate void DelegateTest();
        //有参无返回值的委托
        public delegate void DelegateTest2(int num,string str);
        //有参有返回值的委托
        public delegate int DelegateTest3(int num);
        static void Main(string[] args)
        {
            //DelegateTest dt = new DelegateTest(Test); //函数传递的一种方式
            DelegateTest dt = Test;//函数传递
            dt();
            DelegateTest2 dt2 = new DelegateTest2(Test2);
            dt2(80,"张三");
            DelegateTest3 dt3 = Test3;
            int num = dt3(101);
            Console.WriteLine(num);
        }
        public static void Test()
        {
            Console.WriteLine("DelegateTest");
        }
        public static void Test2(int num,string str)
        {
            Console.WriteLine($"{str}:{num}");
        }
        public static int Test3(int num)
        {
            Console.WriteLine(num);
            return num;
        }
    }
}

Délégué multidiffusion :

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DelegateTest
{
    internal class Program
    {
        //多播委托：可以合并或移除多个委托对象，多播委托被调用时，它所合并的方法组或方法列表都会被调用，而且只有相同类型的委托对象才能合并
        public delegate void DelegateTest();
        static void Main(string[] args)
        {
            DelegateTest dt = Test;//函数传递
            dt += Test2;//合并
            DelegateTest dt2 = Test3;
            dt += dt2;//合并
            dt();
            dt -= Test2;//移除
            dt();
        }
        public static void Test()
        {
            Console.WriteLine("Test");
        }
        public static void Test2()
        {
            Console.WriteLine("Test2");
        }
        public static void Test3()
        {
            Console.WriteLine("Test3");
        }
    }
}

Délégation anonyme :

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DelegateTest
{
    internal class Program
    {
        delegate void DelegateTest();
        static void Main(string[] args)
        {
            //匿名委托
            DelegateTest dt = delegate () { Console.WriteLine("匿名委托"); };
            //Lambda表达式的写法
            DelegateTest dt2 = () => Console.WriteLine("Lambda");
            dt += Show;
            dt();
            dt += dt2;
            dt();
        }
        static void Show()
        {
            Console.WriteLine("Show");
        }
    }
}

2. Evénement : cela équivaut à enregistrer le tableau d'attribution, qui est basé sur l'attribution. Un événement est un type spécial de délégué, par lequel plusieurs délégués et méthodes peuvent être enregistrés et annulés. Il s'agit d'une collection de délégués et de méthodes nécessaires pour effectuer les opérations de l'utilisateur.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DelegateTest
{
    internal class Program
    {
        public delegate void DelegateTest();
        //定义事件：事件是一个特殊的委托，事件可以作为变量拿到类之外去使用，但是发布必须在定义类里面实现
        public static event DelegateTest EventDT;
        static void Main(string[] args)
        {
            Student student = new Student();
            student.GetInfo();//驱动方法内的事件进行注册
            EventDT();//事件发布
        }
    }
    class Student
    {
        private string name;
        private int age;
        //访问器
        public string Name
        {
            set { name = value; }
            get { return name; }
        }
        public int Age
        {
            get => age; set => age = value;
        }
        public void ShowInfo()
        {
            Console.WriteLine("张三：18");
        }
        public void ShowInfo2()
        {
            Console.WriteLine("李四：19");
        }
        public void GetInfo()
        {
            Program.DelegateTest dt = ShowInfo2;
            Program.EventDT += ShowInfo;//注册方法
            Program.EventDT += dt;//注册委托
        }
    }
}

3. La différence entre délégué et événement :

(1) Le délégué peut être déclaré à l'intérieur et à l'extérieur de la classe. Les événements ne peuvent être déclarés qu'au sein d'une classe.
(2) Les délégués et les événements peuvent être enregistrés et non enregistrés dans la classe et en dehors de la classe, mais les événements ne peuvent être appelés qu'à l'intérieur de la classe, tandis que les délégués peuvent être appelés à l'extérieur de la classe à l'intérieur de la classe. L'utilisation d'événements peut améliorer la sécurité des appels et empêcher les événements d'être appelés Les autorisations sont utilisées avec désinvolture par d'autres
(3) Les délégués sont particulièrement utilisés pour implémenter des événements et des méthodes de rappel. C # utilise des événements pour implémenter la communication entre les threads, tout comme une interface externe

référence:

https://www.runoob.com/csharp/csharp-delegate.html
https://www.runoob.com/csharp/csharp-event.html
https://blog.csdn.net/shanniuliqingming/article/details/ 119547799?spm=1001.2014.3001.5506

Conclusion : L'arbre qui embrasse naît au bout des cheveux ; la plate-forme de neuf étages part du tas de terre ; le voyage de mille lieues commence par un seul pas.