Enterprise Service Bus libraries for .NET – MassTransit

One in a series of posts giving a quick overview of ESB libraries for .NET

MassTransit is an open-source library which apparently began as a response to some perceived deficiencies in the version of NServiceBus that was around in 2007. The project did a major rewrite in 2014, introducing async support and switching from MSMQ to RabbitMQ as the preferred transport.

Messages

Messages are POCO classes. There is no requirement to inherit from any base class or implement a specific interface.

Publishing

http://masstransit-project.com/MassTransit/usage/producing-messages.html

Messages are published using IPublishEndpoint, which is provided by ConsumeContext for consumers or by the IBus interface

public async Task NotifyOrderSubmitted(IPublishEndpoint publishEndpoint)
{
    await publishEndpoint.Publish<OrderSubmitted>(new
    {
        OrderId = "27",
        OrderDate = DateTime.UtcNow,
    });
}

Subscribing

http://masstransit-project.com/MassTransit/usage/message-consumers.html

A subscribing class (or consumer) implements the IConsumer<T> interface.

public class UpdateCustomerConsumer :
    IConsumer<UpdateCustomerAddress>
{
    public async Task Consume(ConsumeContext<UpdateCustomerAddress> context)
    {
        await Console.Out.WriteLineAsync($"Updating customer: {context.Message.CustomerId}");

        // update the customer address
    }
}

A consumer needs to be connected to an endpoint to receive messages

var busControl = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
    var host = cfg.Host(new Uri("rabbitmq://localhost/"), h =>
    {
        h.Username("guest");
        h.Password("guest");
    });

    cfg.ReceiveEndpoint(host, "customer_update_queue", e =>
    {
        e.Consumer<UpdateCustomerConsumer>();
    });
});

Enterprise Service Bus libraries for .NET – NServiceBus

One in a series of posts giving a quick overview of ESB libraries for .NET

Originally an open-source library developed by Udi Dahan, the licensing was changed after version 2 to put it on a more commercial footing, and the software is now developed and supported by Udi’s company – Particular Software. The source code remains on Github.

NServiceBus is a tried and tested library. It has grown a lot since it’s humble beginnings and now is once part of a suite of tools and libraries for building distributed applications. It’s no surprise that Udi Dahan just happens to be highly regarded as an expert in distributed software architecture.

https://docs.particular.net/nservicebus/messaging/publish-subscribe/publish-handle-event

Messages

Messages need to either implement a marker interface or use defined conventions.

namespace Domain.Messages
{
  public class UserCreatedEvent : IEvent
  {
    public string Name { get; set; }
  }
}

Or

var conventions = endpointConfiguration.Conventions();

conventions.DefiningEventsAs(
 type =>

     {
       return type.Namespace == "MyNamespace.Messages.Events";
 });

Publishing

You can publish an event from within another handler or when you create an endpoint. This example shows publishing an event from an endpoint:

var endpointInstance = await Endpoint.Start(endpointConfiguration)
    .ConfigureAwait(false);
    await endpointInstance.Publish(new MyEvent())
      .ConfigureAwait(false);

Subscribing

To handle an event, implement IHandleMessages<T>

public class UserCreatedHandler : IHandleMessages<UserCreatedEvent>
{
  public Task Handle(UserCreatedEvent message, IMessageHandlerContext context)
  { … }
}

NServiceBus will automatically locate handlers by looking for implementations of IHandleMessages<T>

Enterprise Service Bus libraries for .NET

As a software application becomes larger, you may want to break it into separate parts, both to manage complexity but also to aid scalability. But if you break an application apart, how will the separate parts communicate? One approach is to employ messaging using a publish/subscribe (pub/sub) bus.

A few years ago, I worked on an application that used NServiceBus just for this purpose, but I thought it would be useful to survey the .NET landscape to find out what’s available today.

Here’s a summary of the libraries I’ll be looking at over the next few blog posts:

These libraries range from the relatively simple and tightly focused to the complete ‘enterprise-level’ configurable, extensible and/or fully supported.

Some of these libraries distinguish between an ‘event’ (notify subscribers that something has happened) and a ‘command’ (tell subscribers that they should perform an action). Some support long-running business processes, often known as ‘sagas’. Some support distributed transactions. Some use dependency injection and can integrate with an inversion-of-control container.

And because the feature sets vary so widely, I’ll just be highlighting how each library implements publishing an ‘event’ message, and how you subscribe to these messages.