IMessageHandler

CloudNimble.SimpleMessageBus.Core.IMessageHandler

public class OrderMessageHandler : IMessageHandler
{
    private readonly IOrderService _orderService;

    public OrderMessageHandler(IOrderService orderService)
    {
        _orderService = orderService;
    }

    public IEnumerable<Type> GetHandledMessageTypes()
    {
        yield return typeof(OrderCreatedMessage);
        yield return typeof(OrderUpdatedMessage);
    }

    public async Task OnNextAsync(MessageEnvelope messageEnvelope)
    {
        switch (messageEnvelope.Message)
        {
            case OrderCreatedMessage created:
                await _orderService.ProcessNewOrderAsync(created);
                break;
            case OrderUpdatedMessage updated:
                await _orderService.UpdateOrderAsync(updated);
                break;
        }
    }

    public async Task OnErrorAsync(IMessage message, Exception exception)
    {
        // Log the error and potentially send notifications
        await _orderService.HandleProcessingErrorAsync(message, exception);
    }
}

System.Collections.Generic.IEnumerable<System.Type> GetHandledMessageTypes()

public IEnumerable<Type> GetHandledMessageTypes()
{
    yield return typeof(OrderCreatedMessage);
    yield return typeof(OrderCancelledMessage);
    yield return typeof(OrderShippedMessage);
}

System.Threading.Tasks.Task OnErrorAsync(CloudNimble.SimpleMessageBus.Core.IMessage message, System.Exception exception)

public async Task OnErrorAsync(IMessage message, Exception exception)
{
    _logger.LogError(exception, "Failed to process {MessageType} with ID {MessageId}",
        message.GetType().Name, message.Id);

    // Send alert for critical messages
    if (message is CriticalBusinessMessage)
    {
        await _alertService.SendFailureAlertAsync(message, exception);
    }
}

System.Threading.Tasks.Task OnNextAsync(CloudNimble.SimpleMessageBus.Core.MessageEnvelope messageEnvelope)

public async Task OnNextAsync(MessageEnvelope messageEnvelope)
{
    // Extract metadata if available
    var userId = messageEnvelope.Metadata?.GetValueOrDefault("UserId");

    // Process based on message type
    switch (messageEnvelope.Message)
    {
        case OrderCreatedMessage order:
            await ProcessOrderAsync(order, userId?.ToString());
            break;
        default:
            throw new NotSupportedException($"Message type {messageEnvelope.Message.GetType()} not supported");
    }
}