Ready C# Events

Each event has a type.
Let's take the event Click. The type of the event Click is EventHandler and both event and its type are defined fortunatelly in .NET Framework. We only have to keep in mind that Click IS an event of type EventHandler (whatever this means).

And here is the good news : We have the Click event handy defined for us.

We have to supply some program code (method) which to response when that (Click) event is raised.

So, using the convention, we'll create a simple method, named "Clicked", which we intend to use in response of a Click event:

void Clicked(object sender, System.EventArgs e)
{
// Here goes the code for this (Click) event
MessageBox.Show("Button has been clicked.");
}

But…, wait…, WAIT !!!

What are these object…, Event… bla, bla, bla for !?!

Well . . . ,

here comes the bad news. We know that the Click event exists but it is enough. Additionally we mist know also what the type of the event is. (The event HAS a type, remember?)

The type of the event Click IS EventHandler.

For our purpouse this means: we must supply these … things in parenthesis as a signature of our method. These objects – object and System.EventArgs ("sender" and "e" are just names!) are required because of the definition of the type.

Finally, we have to attach our beautiful method "Clicked" to the event of the desired object.

To keep things simple I'll attach the method to the form itself so the form is once clicked, the method will be fired.

this.Click += new EventHandler(this.Clicked);

Explain?

OK here we have (from left to right):

1.  
   1. this – please see 1.
   2. Clicked – wow, et last! Here it is – our method is a part of the form and is attached!

2. this – this form, of course (this is a special keyword, do you know? Ah, OK, fine.)
3. Click – we intended to attach our method to the click event, remember?
4. += – be nice, just add our great method to the others
5. new – what are we adding? Object of course, and it is a NEW object (another keyword, you know…).
6. EventHandler – it is a new object, right? So pass here its constructor.

Remember! EventHandler is a sort of pointer, so where is it point to?

7. this.Clicked – voila! – this is where it is pointing to.

Headache?

OK, let's explain in brief what was this all:

Step One:

We create a method with a name choosen by us but with two mandatory parametars – 1st object, 2nd – System.EventArgs.

Step Two:

We attach this very methos to the desired event using += operator and creating a new EventHandler type object passing our method as a parameter.

Clear?

Here is the code for review:

using System;
using System.ComponentModel;
using System.Windows.Forms;
using System.Drawing;

class Evnt : Form
{
public Evnt()
{
this.Click += new EventHandler(this.Clicked);
}

void Clicked(object sender, System.EventArgs e)
{
MessageBox.Show("Button has been clicked.");
}

static void Main ( )
{
Application.Run(new Evnt());
}
}

A final question: What if we do not add these two parameters in our so nice method?

Well…, error of course! Because "An instance of the delegate can bind to any method that matches its signature"

Otherwise error CS0123: Method 'Evnt.Button_Clicked()' does not match delegate 'void System.EventHandler(object, System.EventArgs)' will occur.

NB:
"A delegate is a class that can hold a reference to a method. Unlike other classes, a delegate class has a signature, and it can hold references only to methods that match its signature."

If event is not defined

Well, if we want to use it, we must define it. And here is how we could:

public event EventHandler Click;

Let's explain what we've done:

1. public – so if you want – you can use it.
2. event – this will tell you that it is an action.
3. EventHandler – this is the type of the action
4. Click – this is the name we use to distinguish this event from the others.