Compilation of C# basic knowledge Basic knowledge (21) Delegation (2)

After reading the previous article on the usage of delegation, we see that

        public void Description(string programerName, DescriptionDelegate description)
        {
            description(programerName);
        }

This method passes a DescriptionDelegate description delegate type in, so for this method, Make some modifications to make it easier to use and the code will be more reasonable. Encapsulate the delegate, and then propose programmer description methods in different languages:
Encapsulation:

    public class ProgramDescriptionDelegate2
    {
        public delegate void DescriptionDelegate(string programerName);

        public DescriptionDelegate myDelegate;

        public void Description(string programerName)
        {
            myDelegate(programerName);
        }
    }

Proposed class:

    public class TestDescriptionDelegate2
    {
        public void CsharpProgramer(string programerName)
        {
            Console.WriteLine(string.Format("{0} 使用C#编程!", programerName));
        }

        public void CProgramer(string programerName)
        {
            Console.WriteLine(string.Format("{0}使用C语言编程!", programerName));
        }

        public void JavaProgramer(string programerName)
        {
            Console.WriteLine(string.Format("{0} 使用Java语言编程!", programerName));
        }

        public void Test()
        {
            ProgramDescriptionDelegate2 pe = new ProgramDescriptionDelegate2();

            pe.myDelegate = CsharpProgramer;

            pe.myDelegate += CProgramer;

            pe.Description("SamYang");
        }
    }

This is more reasonable, because public void CsharpProgramer (string programerName) These methods should be defined by users at any time and can be regarded as changing at any time. ProgramDescriptionDelegate2 is entirely a public class, and it is only responsible for executing methods bound to the delegate.
Call:

            TestDescriptionDelegate2 t = new TestDescriptionDelegate2();

            t.Test();

Output:

Look back at the ProgramDescriptionDelegate2 class, public DescriptionDelegate myDelegate; should be a field, according to the object-oriented encapsulation, the field To be encapsulated as attributes. So here we have to use a very useful field event to encapsulate it.
Encapsulation is as follows:

   public class ProgramerDescriptionEvent
    {
        public delegate void DescriptionDelegate(string programerName);

        private event DescriptionDelegate myEvent;

        public event DescriptionDelegate MyEvent
        {
            add { this.myEvent += value; }

            remove { this.myEvent -= value; }
        }

        public void Description(string programerName)
        {
            myEvent(programerName);
        }
    }

  public class TestEvent
    {
        public void CsharpProgramer(string programerName)
        {
            Console.WriteLine(string.Format("{0} 使用C#编程!", programerName));
        }

        public void CProgramer(string programerName)
        {
            Console.WriteLine(string.Format("{0}使用C语言编程!", programerName));
        }

        public void JavaProgramer(string programerName)
        {
            Console.WriteLine(string.Format("{0} 使用Java语言编程!", programerName));
        }

        public void Test()
        {
            ProgramerDescriptionEvent pe = new ProgramerDescriptionEvent();

            pe.MyEvent += CsharpProgramer;

            pe.MyEvent += JavaProgramer;

            pe.Description("SamYang");//一般这个执行是放在引起事件执行的地方
        }
    }

Call:

            TestEvent te = new TestEvent();

            te.Test();

The result is as follows:

It can be seen that what is an event, in fact Essentially, delegation is used, but using event turns delegation into a mechanism called an event.
Then look at msdn's description of delegation and events:
Events are messages sent by objects to signal the occurrence of operations. The operations may be caused by user interaction (mouse, keyboard operations, etc.), or by some Other program logic triggers. An object that captures an event and responds to it is called an event receiver.
In event communication, the event sender class does not know which object or method will receive the event it raises. All that is required is the existence of an intermediary between the source and the receiver. The .NET Framework defines a special type (Delegate) that provides the functionality of a function pointer. A delegate is a class that holds a reference to a method. Unlike other classes, a delegate class has a signature, and it can only reference methods that match its signature. In this way, the delegate is equivalent to a type-safe function pointer or a callback. Although delegates have many other uses, only the event handling functionality of delegates will be discussed here. A delegate declaration is sufficient to define a delegate class. The declaration provides the signature of the delegate, and the common language runtime provides the implementation. For example:
public delegate void AlarmEventHandler(object sender, AlarmEventArgs e);
delegate keyword informs the compiler that AlarmEventHandler is a delegate type. By convention, event delegates in the .NET Framework have two parameters: the source that raised the event and the event's data. That is sender and e.

The above is the content of the basic knowledge of C#, basic knowledge (21) and commission (2). For more related content, please pay attention to the PHP Chinese website (m.sbmmt.com)!