Tolitech.Application.Messaging 1.0.0-preview.4

Tolitech.Application.Messaging

Overview

Tolitech.Application.Messaging is a lightweight .NET library designed to simplify the implementation of event-driven architectures. It provides abstractions for event bus, integration event handling, and the Outbox pattern, enabling reliable and scalable messaging between microservices and distributed systems.

Features

• Event Bus Abstraction: Interface for publishing integration events asynchronously.
• Integration Event Handler: Interface for handling events, compatible with MassTransit consumers.
• Outbox Pattern: Interface for reliable event registration and deferred processing.
• MassTransit Integration: Built to work seamlessly with MassTransit and Tolitech.Messaging.IntegrationEvents.
• Extensibility: Easily integrate with custom infrastructure and business logic.

Main Interfaces

IEventBus

Abstraction for publishing integration events.

public interface IEventBus
{
    Task PublishAsync<T>(T message, CancellationToken cancellationToken)
        where T : IIntegrationEvent;
}

IIntegrationEventHandler<TMessage>

Handler for integration events (MassTransit consumer).

public interface IIntegrationEventHandler<in TMessage> : IConsumer<TMessage>
    where TMessage : class, IIntegrationEvent;

IOutbox

Outbox pattern for reliable event registration and deferred processing.

public interface IOutbox
{
    void RegisterIntegrationEvent(IIntegrationEvent ev);
    void RegisterIntegrationEvent(IIntegrationEvent ev, TimeSpan delay);
    void RegisterIntegrationEvent(IIntegrationEvent ev, DateTimeOffset enqueueAt);
    IReadOnlyList<IntegrationEventEnvelope> GetIntegrationEventEnvelopes();
    void ClearIntegrationEventEnvelopes();
}

Example Usage

Publishing an Event

public class OrderCreatedIntegrationEvent : IIntegrationEvent
{
    public Guid OrderId { get; set; }
}

// Publishing the event
await eventBus.PublishAsync(new OrderCreatedIntegrationEvent { OrderId = orderId }, cancellationToken);

Handling an Event

public class OrderCreatedHandler : IIntegrationEventHandler<OrderCreatedIntegrationEvent>
{
    public async Task Consume(ConsumeContext<OrderCreatedIntegrationEvent> context)
    {
        // Handle the event
        var orderId = context.Message.OrderId;
    }
}

Using the Outbox

// Register event for later processing
outbox.RegisterIntegrationEvent(new OrderCreatedIntegrationEvent { OrderId = orderId });

// Register with delay
outbox.RegisterIntegrationEvent(new OrderCreatedIntegrationEvent { OrderId = orderId }, TimeSpan.FromMinutes(10));

// Register for specific time
outbox.RegisterIntegrationEvent(new OrderCreatedIntegrationEvent { OrderId = orderId }, DateTimeOffset.UtcNow.AddHours(1));

// Retrieve and clear events
var envelopes = outbox.GetIntegrationEventEnvelopes();
outbox.ClearIntegrationEventEnvelopes();

Integration Steps

1. Reference Tolitech.Application.Messaging in your project.
2. Implement your integration events and handlers using the provided interfaces.
3. Register handlers with MassTransit and configure the event bus.
4. Use the Outbox for reliable event registration if needed.

Summary

Tolitech.Application.Messaging streamlines event-driven development in .NET, providing robust abstractions for messaging, event handling, and reliability in distributed systems.