C# Generic Events - Creating and Consuming Events in Your Application

In this blog post, we’ll explore how to create a generic event trigger and consume events in Your Application. This code allows you to efficiently manage and respond to events in your applications. To demonstrate its usage, we’ll build a simplified example based on a hypothetical e-commerce system where we handle order-related events. This example will illustrate the power and flexibility of a generic event trigger framework.

Step 1: Define Generic Event and Event Handler

Let’s start by defining a generic event class and a generic event handler interface. This generic approach allows us to handle various types of events with ease.

public class Event<T>
{
    public T Data { get; }

    public Event(T data)
    {
        Data = data;
    }
}

public interface IEventHandler<T>
{
    void Handle(Event<T> @event);
}

In this code, the Event<T> class represents an event with data of type T, and the IEventHandler<T> interface defines the contract for event handlers.

Step 2: Create an Event Dispatcher

Our event trigger framework requires a central event dispatcher responsible for registering event handlers and dispatching events to those handlers. Here’s the implementation of the event dispatcher:

public class EventDispatcher
{
    private readonly Dictionary<Type, List<object>> _eventHandlers = new Dictionary<Type, List<object>>();

    public void RegisterHandler<TEvent>(IEventHandler<TEvent> handler)
    {
        var eventType = typeof(TEvent);

        if (!_eventHandlers.ContainsKey(eventType))
        {
            _eventHandlers[eventType] = new List<object>();
        }

        _eventHandlers[eventType].Add(handler);
    }

    public void Dispatch<TEvent>(Event<TEvent> @event)
    {
        var eventType = typeof(TEvent);

        if (_eventHandlers.ContainsKey(eventType))
        {
            foreach (var handler in _eventHandlers[eventType])
            {
                ((IEventHandler<TEvent>)handler).Handle(@event);
            }
        }
    }
}

This EventDispatcher class is responsible for registering event handlers and dispatching events to those handlers.

Step 3: Implement Event Handlers

In our e-commerce system example, let’s create some specific event classes and corresponding event handlers. These events simulate order-related events.

public class OrderPlacedEvent
{
    public string OrderId { get; }

    public OrderPlacedEvent(string orderId)
    {
        OrderId = orderId;
    }
}

public class OrderShippedEvent
{
    public string OrderId { get; }

    public OrderShippedEvent(string orderId)
    {
        OrderId = orderId;
    }
}

public class OrderPlacedHandler : IEventHandler<OrderPlacedEvent>
{
    public void Handle(Event<OrderPlacedEvent> @event)
    {
        Console.WriteLine($"Order placed: {@event.Data.OrderId}");
        // Add your custom order processing logic here
    }
}

public class OrderShippedHandler : IEventHandler<OrderShippedEvent>
{
    public void Handle(Event<OrderShippedEvent> @event)
    {
        Console.WriteLine($"Order shipped: {@event.Data.OrderId}");
        // Add your custom order processing logic here
    }
}

Here, we’ve defined OrderPlacedEvent, OrderShippedEvent, and their corresponding event handlers.

Step 4: Usage

Now, let’s see how to use our generic event trigger framework in your application:

static void Main()
{
    var eventDispatcher = new EventDispatcher();

    var orderPlacedHandler = new OrderPlacedHandler();
    var orderShippedHandler = new OrderShippedHandler();

    eventDispatcher.RegisterHandler(orderPlacedHandler);
    eventDispatcher.RegisterHandler(orderShippedHandler);

    // Trigger events
    var orderPlacedEvent = new Event<OrderPlacedEvent>(new OrderPlacedEvent("12345"));
    var orderShippedEvent = new Event<OrderShippedEvent>(new OrderShippedEvent("12345"));

    eventDispatcher.Dispatch(orderPlacedEvent);
    eventDispatcher.Dispatch(orderShippedEvent);

    Console.ReadLine();
}

In this example, we’ve created an instance of EventDispatcher, registered event handlers, and dispatched events. When you run this program, you’ll see the event handling messages printed to the console.

Conclusion

In this blog post, we’ve demonstrated how to create a generic event trigger in C#. This code allows you to efficiently manage and respond to events in your applications, making your code more modular and maintainable. You can extend this framework to handle various types of events and build more complex event-driven systems. Event-driven programming is a powerful paradigm that can improve the scalability and flexibility of your applications, making them easier to maintain and extend.