C# Delegate: Everything You Need To Know About Delegate In C#

What is a Multicast delegate in C#?

A sample code demonstrates how to create and use a multicast delegate.

using System;

namespace delegate_Example4
{
    class Program
    {
        public delegate void delmethod(int x, int y);

        public class TestMultipleDelegate
        {
            public void plus_Method1(int x, int y)
            {
                Console.Write("You are in plus_Method");
                Console.WriteLine(x + y);
            }

            public void subtract_Method2(int x, int y)
            {
                Console.Write("You are in subtract_Method");
                Console.WriteLine(x - y);
            }
        }

        static void Main(string[] args)
        {
            TestMultipleDelegate obj = new TestMultipleDelegate();
            delmethod del = new delmethod(obj.plus_Method1);

            // Here we have multicast
            del += new delmethod(obj.subtract_Method2);
            // plus_Method1 and subtract_Method2 are called
            del(50, 10);
            Console.WriteLine();
            // Here again we have multicast
            del -= new delmethod(obj.plus_Method1);
            // Only subtract_Method2 is called
            del(20, 10);
            Console.ReadLine();
        }
    }
}

Points to remember about Delegates.

• Delegates are similar to C++ function pointers but are type-safe.
• The delegate gives a name to a method signature.
• Delegates allow methods to be passed as parameters.
• Delegates can be used to define callback methods.
• Delegates can be chained together; for example, multiple methods can be called on a single event.
• C# version 2.0 introduces the concept of Anonymous Methods, which permits code blocks to be passed as parameters in place of a separately defined method.
• Delegate helps in code optimization.
• Usage areas of delegates

The most common example of using delegates is in events.

• They are extensively used in threading
• Delegates are also used for the generic class libraries, which have generic functionality defined.

What are Anonymous Delegates in C#?

You can create a delegate, but there is no need to declare the method associated with it. You do not have to explicitly define a method before using the delegate. Such a method is referred to as anonymous. In other words, if a delegate contains its method definition, it is an anonymous method.

The code is an example of using an anonymous delegate.

using System;

public delegate void Test();

public class Program
{
    static int Main()
    {
        Test Display = delegate()
        {
            Console.WriteLine("Anonymous Delegate method");
        };

        Display();
        return 0;
    }
}

Note. You can also handle events in an anonymous method.

How are Delegates Related to Events in C#?

Events and delegates work together. An event is a reference to a delegate, i.e., when an event is raised, a delegate is called. In C# terms, events are a special form of delegates.

Events play an important part in user interfaces and programming notifications. Events and delegates work hand-in-hand to communicate between codes from one class to another. Events are used when something happens in one class or part of the code and another part needs a notification.

A C# event is a class member that is activated whenever the event it was designed for occurs. It starts with a class that declares an event. Any class, including the same class that the event is declared in, may register one of its methods for the event. This occurs through a delegate, which specifies the signature of the registered method for the event. The event keyword is a delegate modifier. It must always be used in connection with a delegate.

The delegate may be one of the pre-defined .NET delegates or one you declare yourself. Whichever is appropriate, you assign the delegate to the event, which effectively registers the method that will be called when the event fires.

How to Use Events and Delegates in C#?

Once an event is declared, it must be associated with one or more event handlers before it can be raised. An event handler is nothing but a method that is called using a delegate. Use the += operator to associate an event with an instance of a delegate that already exists.

Example

obj.MyEvent += new MyDelegate(obj.Display);

An event has the value null if it has no registered listeners.

Although events are mostly used in Windows control programming, they can also be implemented in console, web, and other applications.

Program for creating a custom Singlecast delegate and event.

using System;

namespace delegate_custom
{
    class Program
    {
        public delegate void MyDelegate(int a);

        public class XX
        {
            public event MyDelegate MyEvent;

            public void RaiseEvent()
            {
                MyEvent(20);
                Console.WriteLine("Event Raised");
            }

            public void Display(int x)
            {
                Console.WriteLine("Display Method {0}", x);
            }
        }

        static void Main(string[] args)
        {
            XX obj = new XX();
            obj.MyEvent += new MyDelegate(obj.Display);

            obj.RaiseEvent();
            Console.ReadLine();
        }
    }
}

Program for creating custom multiplecast delegates and events.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace delegate_custom_multicast
{
    class Program
    {
        public delegate void MyDelegate(int a, int b);

        public class XX
        {
            public event MyDelegate MyEvent;

            public void RaiseEvent(int a, int b)
            {
                MyEvent(a, b);
                Console.WriteLine("Event Raised");
            }

            public void Add(int x, int y)
            {
                Console.WriteLine("Add Method {0}", x + y);
            }

            public void Subtract(int x, int y)
            {
                Console.WriteLine("Subtract Method {0}", x - y);
            }
        }

        static void Main(string[] args)
        {
            XX obj = new XX();
            obj.MyEvent += new MyDelegate(obj.Add);
            obj.MyEvent += new MyDelegate(obj.Subtract);
            obj.RaiseEvent(20, 10);
            Console.ReadLine();
        }
    }
}

Conclusion

I hope the article has helped you understand delegates and events.

You may want to read another article on Delegates and Events: Mastering Delegates and Events In C# .NET (c-sharpcorner.com).