MicroBus: In-Process Mediator

I’ve blogged about the mediator pattern a lot. Primarily because it’s been a good fit in several of the applications I’ve developed over the last few years.

Mediator Pattern

For those completely unfamiliar with the mediator pattern, here’s a brief summary:

With the mediator pattern, communication between objects is encapsulated with a mediator object. Objects no longer communicate directly with each other, but instead communicate through the mediator. This reduces the dependencies between communicating objects, thereby lowering the coupling.

Libraries

I’ve written my own implementations of the mediator library from project to project. Once I finally found the MediatR library, I’ve pretty much been using it instead of my own.

In a recent post about MediatR v3’s new Behaviors, Daniel Little commented about his implementation called MicroBus.

I love checking out new libraries to see what’s out there. I’ve gotten a lot of feedback about other OSS libraries and tools I’ve blogged about.

I figured this was a good opportunity to mention library that look pretty interesting and may be worth taking a deeper look at.

MicroBus

This library actually looks more like what I’ve built myself in the past.

The first thing to notice is there are two separate interfaces for defining a Command or a Query.

	public interface ICommand : IMessage { }

	public interface IQuery<in TQuery, out TResult> : IQuery, IMessage where TQuery : IQuery<TQuery, TResult> { }

	public interface IQuery { }

	public interface IEvent : IMessage { }

view raw ICommandQueryEvent.cs hosted with ❤ by GitHub

There isn’t anything surprising when you look at implement your handlers. It’s pretty straight forward and what you would expect. Familiar things are nice.

	public class PaymentCommand : ICommand { }

	public class PaymentHandler : ICommandHandler<PaymentCommand>
	{
	public async Task Handle(PaymentCommand command)
	{
	// Do some stuff...
	}
	}

view raw CommmandHandler.cs hosted with ❤ by GitHub

Cross Cutting Handlers

What’s really interesting is how it handles cross cutting concerns. You can create global handlers via the IDelegatedHandler interface or create a pipeline with IPipeline interface.

	public interface IDelegatingHandler
	{
	Task<object> Handle(INextHandler next, object message);
	}

	public interface IPipelineHandler
	{
	Task<object> Handle(Func<IMessage, Task<object>> next, IMessage message);
	}

view raw xcutting.cs hosted with ❤ by GitHub

BusBuilder

Another interesting aspect is how you build up registering your handlers. There is built in support for Autofac

	var busBuilder = new BusBuilder()

	// Global Handlers
	.RegisterGlobalHandler<LoggingHandler>()

	// Scan an assembly for all other command/query/event handlers
	.RegisterHandlers(assembly);

	autofacContainerBuilder.RegisterMicroBus(busBuilder);

view raw register.cs hosted with ❤ by GitHub

Comments

From the looks of it MicroBus looks like a pretty nice implementation of the mediator pattern with a lot of features people are looking for such as pipelines.

Check it out on GitHub. It is a very active project (as of this posting).

If you want to see a real world demo, possibly of my MusicStore sample app but using MicroBus, please let me know!

If you have another library you would like me to blog about feel please let me know in the comments or on Twitter.

Follow @codeopinion