Events and Delegates in C#.NET

Short intro

Many developers have already written some blog posts or articles regarding this subject. In the following blog, I will try to explain the concepts of using Events and Delegates in C#.NET and will try to keep it as simpler as possible, in order to give clear view to all those who are confused, especially about delegates.

The first time I’ve started learning about C#.NET from its very first version, the first new thing for this programming language I heard is that it does not uses pointers and references. From the university days as a student, I’ve started with C++. Once I learnt the Pointers and References, I get used to work a lot with them, so I was confused why C# does not uses pointers. Then, after reading my first book about C#, I’ve noticed that there are delegates that replaces the functionality of pointers. And, after testing some scenarios, it came out that delegates are very interesting and great thing introduced in C# that can be used for some specific cases.

Events and Delegates

The simplest and most important thing we should know is that Events are declared by using Delegates.

Shortly, as the keyword refers, an Event is something that happens in a certain situation while the application runs. For instance, you have list of ‘things’ and you want an event to happen if new ‘thing’ is added to that list. More specifically, lets say you have an application that manages the opened documents. So if new document is opened, you want to fire an event.
Another example would be, just add a control in your ASPX page or any .NET application, in the Properties go to the Events list. You will see various events that happen in a certain time while control is initiated, rendered, loaded, unloaded and so on. Then, you can create your own method related to any of these events, code that will run in that certain event when it will happen. The click event is well known to everyone because almost everyone have used it from the very beginning of programming in ASP.NET / C#.NET / VB.NET… So this event happens when the control is clicked. (I hope these examples are enough to help you understand the very basic theory of ‘events’).

Delegates is a concept (as I’ve mentioned previously) used since the beginning of C# language. If you know about methods, you can think of delegate as a method without type (see example bellow)

Example:

delegate void MyMethod();

So, this is completely same as if you have written as interface in the following way

        interface MyInterface
        {
            void MyMethod();
        }

Now, as I have mentioned methods previously – the connection between delegates and events are the methods, thus, the method that is implemented in your class to process and receive events is defined by the delegate itself. From this, we can conclude that the delegate defines what the event handler should return as well as what its parameter lists should be.

Complete example of usage Events and Delegates

In the following example, I have created custom event to fire whenever it finds number starting with 3 ending with 9 (counting to 10000).

//declaring the delegate
    public delegate void DelegateFoundNumber(int Number);

    class Numbers
    {
        public event DelegateFoundNumber NumberFound;

        public void FindNumber()
        {
            int c;
            for (c = 0; c <= 10000; c++)
            {
                if (c.ToString().StartsWith("3") && c.ToString().EndsWith("9"))
                {
                    if (NumberFound != null)
                    {
                        NumberFound(c);
                    }
                }
            }
        }
    }
    class EventHandlerClass
    {
        public void NeededNumberFound(int number)
        {
            Console.WriteLine(number);
        }
    }
    class MyMain
    {
        public static void Main()
        {
            Numbers MyNumb = new Numbers();
            EventHandlerClass myEvtCls = new EventHandlerClass();
            MyNumb.NumberFound += new DelegateFoundNumber(myEvtCls.NeededNumberFound);
            MyNumb.FindNumber();
        }
    }

In the above example, I have created three classes: Numbers, EventHandlerClass and MyMain, and one delegate named as DelegateFounderNumber

Basically, Numbers class contains the declaration of the Event called NumberFound and a function FindNumber which is used to loop through the 10000 numbers and check for the first 3 and last 9 number.

Then, an EventHandlerClass that servers as the event handler for the Numbers class with using EventHandlerClass’s method NeededNumberFound, which is used to write the number.

The last MyMain class is the main class of the application itself. It simply calls the FindNumber() method of Numbers object. It first creates new instance of the delegate managing the NeededNumberFound from the EventHandlerClass and adds it to MyNumb object.

SIMPLY RUN THE CODE AND SEE THE RESULTS!!!

Conclusion

To sum up, you should have in mind that both Events and Delegates are used together, especially when you are going to create components that need to have some events in their functionality.

Moreover, I would like to note that:

… events are declared using delegates

… as we have seen in our example, fundamentially, events are just delegates - only the event keyword is literally just an access modifier which prevents code outside the class that declares the event from invoking the event.

… delegates are invoked by its clients once the event is fired.

… delegates are similar (I would say almost same) to C++ function pointers, but are type safe.

… delegates allow methods to be passed as parameters

I hope this was clear and helpful.

Best Regards,
Hajan

This blog post was also posted on mkdot.net community blog:

http://mkdot.net/blogs/hajan/archive/2010/07/15/events-and-delegates-in-c-net.aspx