C ＃ basic 1-events and commissions

entrust

Delegate is simply understood as a variable of function type ( Reference type ), Represents a reference to a method .

Website to explain delegate

Define delegate type

public delegate void KeyDelegate(string key);

Define the processing function of the corresponding delegate type

    public static void PrintString(string key)
    {
        Console.WriteLine(key);
    }

Instantiate variables of delegate type

KeyDelegate keyAevent = new KeyDelegate(DelegateFunc.PrintString);

A delegate can bind multiple event handlers

multiEvent += new KeyDelegate(DelegateFunc.PrintString2);

Use delegate variables , Call all the event handling functions corresponding to the delegate

multiEvent("B");

The difference between delegation and interface

Definition

Interface （interface） It is a set that constrains what functions a class should have , Constrains which methods a class should have , It is convenient for class management and extension , Using interfaces can also solve the single inheritance problem of classes .

entrust （delegate） Is a collection of methods , Using delegates, you can operate on this set of methods , Such as += .

Applicable scenario

Use the interface in the following cases ：

1. Has inherited a class , You can no longer inherit other classes , But I hope to continue to expand other functions
2. When completely abstract
3. When multi person collaboration requires the function of constraint class

Use delegates when ：

1. In the first two processes of event processing ： Defining events ( Commissioned by using )、 The binding event （ The method set corresponding to the operation delegate ）、 Event handler 、 Call event

event

Event is a package of delegation

Events are variables of delegate type

Events use Release - subscribe Model of , The publisher contains Event and delegate definitions The connection between the event and the Commission , Subscriber accept Event and provide event handling

Learning materials

Declaration delegation

public delegate void KeyDelegate(string key);

Claim event

public static event KeyDelegate? keyEvent;

The binding event

EventHandler.keyEvent += DelegateFunc.PrintString2;

Define event handling functions （ Corresponding to the delegate type ）

    public static void PrintString2(string key)
    {
        Console.WriteLine("-" + key + "-");
    }

Call event

keyEvent?.Invoke(key);

Add

Another kind public static event Action<string> keyEvent; The event definition of , among Action<T> Is the abbreviation of delegation , You can quickly declare event variables of delegate types , Unlike the traditional entrusted writing , You need to declare the delegate type first , Then instantiate a delegate variable with the delegate type to use

Func<T> and Action<T>

Complete code

using System;

// 1.1  Declare a delegate type  KeyDelegate
public delegate void KeyDelegate(string key);
class DelegateFunc
{
    // 1.2  Declare the method corresponding to the delegate type   Return value 、 Parameter list and delegate type  KeyDelegate  bring into correspondence with 
    public static void PrintString(string key)
    {
        Console.WriteLine(key);
    }
    // 2.3  Event handler 
    public static void PrintString2(string key)
    {
        Console.WriteLine("-" + key + "-");
    }
}
public static class EventHandler
{
    // 2.1  Before declaring the event , A delegate type must be declared in advance   for example  KeyDelegate
    public static event KeyDelegate? keyEvent;
    // 2.4  Call event 
    public static void CallKeyEvent(string key)
    {
        keyEvent?.Invoke(key);
    }
}
class Program
{
    static void Main()
    {
        // 1.3  Instantiate a variable of delegate type  keyAevent , Corresponding to the delegated function  DelegateFunc.PrintString
        KeyDelegate keyAevent = new KeyDelegate(DelegateFunc.PrintString);

        KeyDelegate multiEvent;
        multiEvent = keyAevent;
        // 1.4  A delegate can use  +=  The operator   Bind multiple event handlers 
        multiEvent += new KeyDelegate(DelegateFunc.PrintString2);

        // 2.2  The binding event 
        EventHandler.keyEvent += DelegateFunc.PrintString2;

        while (true)
        {
            ConsoleKeyInfo key = Console.ReadKey();
            switch (key.Key)
            {
                case ConsoleKey.A:
                    // 1.4 aA
                    keyAevent("A");
                    break;
                case ConsoleKey.B:
                    // 1.4 bB
                    // 1.4 -B-
                    multiEvent("B");
                    break;
                case ConsoleKey.C:
                    // 2.4 c-C-
                    EventHandler.CallKeyEvent("C");
                    break;
                case ConsoleKey.Q:
                    Console.Clear();
                    return;
                default:
                    Console.WriteLine();
                    break;
            }
        }
    }
}