• Enterprise Service Bus libraries for .NET – Nimbus

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

    Nimbus primarily supports the Azure Service Bus as a transport, so if your application is going to run in Azure, then this could be a good choice.

    https://github.com/NimbusAPI/Nimbus/wiki/Publishing-an-Event-on-the-Bus

    Messages

    Event messages should implement IBusEvent

    Publishing

    Publish with an instance of IBus

    _bus.Publish(new NewOrderReceived {CustomerName = "Ricky Bobby"});
    

    Subscribing

    Handle events by implementing IHandleMulticastEvent

    public class ListenForNewOrders : IHandleMulticastEvent
    {
    
        public async Task Handle(NewOrderReceived busEvent)
        {
            Console.WriteLine("I heard about a new order from " + busEvent.CustomerName);
    
            //Do more stuff
        }
    }
    

  • 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>