VL.Messaging.Abstraction 1.1.1

Abstraction Messaging

This package contains the abstraction for potenital message brokers.

Getting Started

1. Install package VL.Messaging.Abstraction

   dotnet add package VL.Messaging.Abstraction
   

2. Interfaces

   public interface IMessageConsumer
   {
       public Task ConsumeAsync(CancellationToken cancellationToken = default);
   }
   
   public interface IMessageHandler<in TMessage> : IMessageHandler where TMessage : Message, new()
   {
       public Task HandleAsync(TMessage message, CancellationToken cancellationToken = default);
   }
   
   public interface IMessageHandlerDescriptor
   {
       public Type MessageType { get; }
   
       public IMessageHandler GetMessageHandler();
   }
   
   public interface IMessagePublisher<in TMessage> where TMessage : Message, new()
   {
       public Task PublishAsync(TMessage message);
   }
   

3. Classes

public abstract class Message
{
    protected Message() : this(Guid.NewGuid(), DateTimeOffset.UtcNow) { }

    protected Message(Guid id, DateTimeOffset creationDate)
    {
        Id = id;
        CreationDate = creationDate;
    }

    public Guid Id { get; }

    public DateTimeOffset CreationDate { get; }

    public string Source { get; set; } = "DefaultSource";
};

public abstract class MessageHandlerBase<TMessage> : IMessageHandler<TMessage> where TMessage : Message, new()
{
    public abstract Task HandleAsync(TMessage message, CancellationToken cancellationToken = default);

    public Task HandleAsync(Message message, CancellationToken cancellationToken = default)
    {
        if (message is null)
        {
            throw new ArgumentNullException(nameof(message));
        }

        if (message is TMessage specificMessage)
        {
            return HandleAsync(specificMessage, cancellationToken);
        }

        throw new InvalidOperationException("Invalid message type." +
            $"Expected type \"{typeof(TMessage).Name}\" instead of \"{message.GetType().Name}\".");
  }
}

public class MessageHandlerDescriptor<TMessage> : IMessageHandlerDescriptor where TMessage : Message, new()
{
    private readonly Func<IMessageHandler> _factory;
  
    public MessageHandlerDescriptor(Func<IMessageHandler<TMessage>> factory)
    {
        MessageType = typeof(TMessage);
        _factory = factory ?? throw new ArgumentNullException(nameof(factory));
    }
  
    public Type MessageType { get; }

    public IMessageHandler GetMessageHandler()
    {
        return _factory();
    }
}