Mastering Delegates and Events In C# .NET

Anonymous methods, as their name implies, are nameless methods. They prevent the creation of separate methods, especially when the functionality can be done without a new method creation. Anonymous methods provide a cleaner and more convenient approach while coding.

Define an anonymous method with the delegate keyword and a nameless function body. This code assigns an anonymous method to the delegate. The anonymous method must not have a signature. The signature and return type is inferred from the delegate type. For example, if the delegate has three parameters and returns a double type, the anonymous method would also have the same signature.

using System;  
  
namespace Delegates  
{  
    class Program  
    {  
        // Delegate Definition  
        delegate void operation();  
  
        static void Main(string[] args)  
        {  
            // Delegate instantiation  
            operation obj = delegate  
            {  
                Console.WriteLine("Anonymous method");  
            };  
            obj();  
   
            Console.ReadLine();  
        }  
    }  
}

The anonymous methods reduce the complexity of code, especially where several events are defined. With the anonymous method, the code does not perform faster. The compiler still defines methods implicitly.

Multicast Delegate

So far, you have seen a single method invocation/call with delegates. If you want to invoke/call more than one method, you must make an explicit call through a delegate more than once. However, it is possible for a delegate to do that via multicast delegates.

A multicast delegate is similar to a virtual container where multiple functions reference a stored invocation list. It successively calls each method in FIFO (first in, first out) order. When you wish to add multiple methods to a delegate object, you use an overloaded += operator rather than a direct assignment.

using System;  
  
namespace Delegates  
{  
    public class Operation  
    {  
        public static void Add(int a)  
        {  
            Console.WriteLine("Addition={0}", a + 10);  
        }  
        public static void Square(int a)  
        {  
            Console.WriteLine("Multiple={0}",a * a);  
        }  
    }  
    class Program  
    {  
        delegate void DelOp(int x);  
   
        static void Main(string[] args)  
        {  
            // Delegate instantiation  
            DelOp obj = Operation.Add;  
            obj += Operation.Square;  
   
            obj(2);  
            obj(8);  
   
            Console.ReadLine();  
        }  
    }  
}

The code above combines two delegates that hold the functions Add() and Square(). Here the Add() method executes first and Square() later. This is the order in which the function pointers are added to the multicast delegates.

To remove function references from a multicast delegate, use the overloaded -= operator that allows a caller to remove a method from the delegate object invocation list dynamically.

// Delegate instantiation  
DelOp obj = Operation.Add;  
obj -= Operation.Square;

Here when the delegate is invoked, the Add() method is executed, but Square() is not because we unsubscribed it with the -= operator from a given runtime notification.

Invoking multiple methods by one delegate may lead to a problematic situation. If one of the methods invoked by a delegate throws an exception, the complete iteration would be aborted. You can avoid such a scenario by iterating the method invocation list. The Delegate class defines a method GetInvocationList that returns an array of Delegate objects.

using System;  
  
namespace Delegates  
{  
    public class Operation  
    {  
        public static void One()  
        {  
            Console.WriteLine("one display");  
            throw new Exception("Error");   
        }  
        public static void Two()  
        {  
            Console.WriteLine("Two display");  
        }  
    }  
  
    class Program  
    {  
        delegate void DelOp();  
  
        static void Main(string[] args)  
        {  
            // Delegate instantiation  
            DelOp obj = Operation.One;  
            obj += Operation.Two;  
  
            Delegate[] del = obj.GetInvocationList();  
  
            foreach (DelOp d in del)  
            {  
                try  
                {  
                    d();  
                }  
                catch (Exception)  
                {  
                    Console.WriteLine("Error caught");  
                }  
            }  
            Console.ReadLine();  
        }  
    }  
}

When you run the application, you will see that the iteration continues with the next method even after an exception is caught, as in the following.

Events

The applications and windows communicate via predefined messages. These messages contain various information to determine window and application actions. The .NET considers these messages as an event. You will handle the corresponding event if you need to react to a specific incoming message. For instance, when a button is clicked on a form, Windows sends a WM_MOUSECLICK message to the button message handler.

You don't need to build custom methods to add or remove methods to a delegate invocation list. C# provides the event keyword. When the compiler processes the event keyword, you can subscribe and unsubscribe methods and any necessary member variables for your delegate types. The syntax for the event definition should be as in the following:

Accessibility event delegatename eventname;

Defining an event is a two-step process. First, you need to define a delegate type that will hold the list of methods to be called when the event is fired. Next, you declare an event using the event keyword. To illustrate the event, we are creating a console application. In this iteration, we will define an event to add that is associated with a single delegate DelEventHandler.

using System;  
  
namespace Delegates  
{  
    public delegate void DelEventHandler();  
  
    class Program  
    {  
        public static event DelEventHandler add;  
   
        static void Main(string[] args)  
        {  
            add += new DelEventHandler(USA);  
            add += new DelEventHandler(India);  
            add += new DelEventHandler(England);  
            add.Invoke();  
   
            Console.ReadLine();  
        }  
        static void USA()  
        {  
            Console.WriteLine("USA");    
        }  
   
        static void India()  
        {  
            Console.WriteLine("India");  
        }  
   
        static void England()  
        {  
            Console.WriteLine("England");  
        }  
    }  
}

In the main method, we associate the event with its corresponding event handler with a function reference. Here, we fill the delegate invocation lists with a couple of defined methods using the +=operator. Finally, we invoke the event via the Invoke method.

Note: Event Handlers can't return a value. They are always void.

Let's use another example to get a better understanding of events. Here we are defining an event name as xyz and a delegate EventHandler with a string argument signature in the operation class. We are putting the implementation in the action method to confirm whether an event is fired or not.

using System;  
  
namespace Delegates  
{  
    public delegate void EventHandler(string a);  
  
    public class Operation  
    {  
        public event EventHandler xyz;  
  
        public void Action(string a)  
        {  
            if (xyz != null)  
            {  
                xyz(a);  
                Console.WriteLine(a);   
            }  
            else  
            {  
                Console.WriteLine("Not Registered");   
            }  
        }  
    }  
   
    class Program  
    {  
        public static void CatchEvent(string s)  
        {  
            Console.WriteLine("Method Calling");  
        }  
  
        static void Main(string[] args)  
        {  
            Operation o = new Operation();  
              
            o.Action("Event Calling");   
            o.xyz += new EventHandler(CatchEvent);  
             
            Console.ReadLine();  
        }  
    }  
}

Later in the Program class, we are defining a CatchEvent method that would be referenced in the delegate invocation list. Finally, we instantiated the operation class and implemented the event firing in the main method.

Finally, we are elaborating on the events with a realistic example of creating a custom button control over the Windows form that would be called from a console application. First, we inherit the program class from the Form class and define its associated namespace at the top. Then, we craft a custom button control in the program class constructor.

using System;  
using System.Drawing;  
using System.Windows.Forms;  
  
namespace Delegates  
{  
    //custom delegate  
    public delegate void DelEventHandler();  
  
    class Program :Form   
    {  
        //custom event  
        public event DelEventHandler add;  
  
        public Program()  
        {  
            // desing a button over form  
            Button btn = new Button();  
            btn.Parent = this;  
            btn.Text = "Hit Me";  
            btn.Location = new Point(100,100);  
  
            //Event handler is assigned to  
            // the button click event  
            btn.Click += new EventHandler(onClcik);  
            add += new DelEventHandler(Initiate);  
  
            //invoke the event  
            add();  
        }  
        //call when event is fired  
        public void Initiate()  
        {  
            Console.WriteLine("Event Initiated");  
        }  
   
        //call when button clicked  
        public void onClcik(object sender, EventArgs e)  
        {  
            MessageBox.Show("You clicked me");    
        }  
        static void Main(string[] args)  
        {  
            Application.Run(new Program());  
   
            Console.ReadLine();  
        }  
    }  
  
} 

We call the Windows Form using the Run method of the Application class. Finally, when the user runs this application, the Event fired message will be displayed on the screen, and a Windows Form with the custom button control will be displayed. When the button is clicked, a message box will be shown as in the following;

Summary