Custom Event Accessors with Delegates

Custom Event Accessors with Delegates.md

Custom Event Accessors with Delegates

In C#, events are often used to provide a way for classes to notify other classes when certain actions or changes occur. Events typically use the event keyword to declare them and are associated with a delegate that defines the event's signature.

However, you can create custom event accessors by directly using delegates, which allows you more control over event subscriptions and unsubscriptions. This is especially useful when implementing custom logic around event handling.

Here's an example:

using System;

public class CustomEventPublisher
{
    private Action<string> customEventHandlers;

    public event Action<string> CustomEvent
    {
        add
        {
            Console.WriteLine("Adding event handler");
            customEventHandlers += value;
        }
        remove
        {
            Console.WriteLine("Removing event handler");
            customEventHandlers -= value;
        }
    }

    public void RaiseEvent(string message)
    {
        customEventHandlers?.Invoke(message);
    }
}

public class Program
{
    public static void Main()
    {
        var publisher = new CustomEventPublisher();

        publisher.CustomEvent += HandleEvent;
        publisher.RaiseEvent("Event 1");

        publisher.CustomEvent += HandleEvent;
        publisher.CustomEvent -= HandleEvent;
        publisher.RaiseEvent("Event 2");
    }

    private static void HandleEvent(string message)
    {
        Console.WriteLine($"Event handled: {message}");
    }
}

In this example, we define a custom event CustomEvent without using the event keyword. Instead, we manually implement the add and remove accessors. This allows us to print messages when handlers are added or removed.

Custom event accessors are powerful when you need to implement custom logic, such as filtering events, logging, or maintaining event handler lists in a specific way. However, they also require you to manage the delegate manually, which can be error-prone, so use them with caution when you need additional control and flexibility.