This can help you to understand events and delegates:
Events in .NET are based on the delegate model. The delegate model follows the observer design pattern, which enables a subscriber to register with and receive notifications from a provider. An event sender pushes a notification that an event has happened, and an event receiver receives that notification and defines a response to it. This article describes the major components of the delegate model, how to consume events in applications, and how to implement events in your code.
An event is a message sent by an object to signal the occurrence of an action. The action can be caused by user interaction, such as a button click, or it can result from some other program logic, such as changing a property’s value. The object that raises the event is called the event sender. The event sender doesn't know which object or method will receive (handle) the events it raises. The event is typically a member of the event sender; for example, the Click event is a member of the Button class, and the PropertyChanged event is a member of the class that implements the INotifyPropertyChanged interface.
To define an event, you use the C# event or the Visual Basic Event keyword in the signature of your event class, and specify the type of delegate for the event. Delegates are described in the next section.
Typically, to raise an event, you add a method that is marked as protected and virtual (in C#) or Protected and Overridable (in Visual Basic). Name this method OnEventName; for example, OnDataReceived. The method should take one parameter that specifies an event data object, which is an object of type EventArgs or a derived type. You provide this method to enable derived classes to override the logic for raising the event. A derived class should always call the OnEventName method of the base class to ensure that registered delegates receive the event.
A simple example is the Button control: when you click on it, the event OnClick is raised and the control call all delegates that have suscribed to it using:
Click += SomeMethod;
Or (it is the same):
Click += new EventHandler(SomeMethod);
If fact, it adds a reference to the method in the event handler list.
An event is just a list of methods to call in case of the event is raised, like with the button click.
A delegate is just a signature of a method without a body implementation, also called a prototype, to be used as a type, to have strong typing when adding events to an event handler like the button click. So when you assign a method implemented, by its name, it must match the delegate signature (return type and parameters, the name of the delegate itself is not pertinent except for humans).
We also can use lambda:
myButton1.Click += (sender, e) => Close();
myButton2.Click += (sender, e) => { MessageBox.Show("Closing"); Close() };
Handling and raising events (MS Docs)
C# - Events(TutorialsPoint)
C# - Events (TutorialsTeacher)
What are C# Events? (YouTube)
C# Tutorial: Events/Event Handlers (YouTube)
