Fat Controller CQRS Diet: Notifications

CQRS NotificationsThis post is in my Fat Controller CQRS Diet series. It demonstrates how to thin your controllers by implementing commands and queries using the MediatR library.

I’m converting the MusicStore application that’s using ASP.NET Core MVC.   All the source code is available on GitHub.

If you’re new to this series, here are earlier posts to get up to speed:

  1. Overview of Series
  2. Simple Query
  3. Simple Command
  4. Command Pipeline

Logging

In the my previous Command Pipeline example, I leveraged StructureMap and the decorator pattern to setup a pipeline.

My pipeline would invoke the actual command handler as well as any classes that implemented the correct IPostRequestHandler<TRequest, TResponse>.

This enabled us to create a AddToCartLogHandler which did our logging that was originally in the ShoppingCartController.AddToCart action method.

Notifications

Another way to implement this is with a Notification (event).

MediatR has this concept built in with a couple interfaces INotification, IAsyncNotification

The concept and how it works with MediatR very similar as a request (Command or Query) and it’s appropriate handler.  The difference with a Notification is it can have many handlers.

  • Request: only one handler
  • Notification: zero to many handlers

Implementation

I’m going to jump back to our AddToCart command.  Instead of it using an IPostRequestHandler<AddToCart, Unit> that I created for our pipeline, I’m going to instead create a notification and publish that notification from MediatR.

First, we need to create a class to represent our notification.  All the class will contain is a property to specify the AlbumId that was added to the shopping cart.

Now we will create a Notification Handler that will accept this new notification object and do the logging.

Finally, our last piece is to Publish a new AlbumAddedToCart notification to MediatR.  We can do so in our AddToCartHandler .

Comments

All the source code for this series is available on GitHub.GitHub

Which do you prefer, Pipeline or notifications? Let me know in the comments or on Twitter.


Fat Controller CQRS Diet: Command Pipeline

Command PipelineThis post is in my Fat Controller CQRS Diet series demonstrating how to thin your controllers by implementing commands and queries using the MediatR library.

For demonstration, I’m converting the MusicStore application that’s using ASP.NET Core MVC.   All the source code is available on GitHub.

If you’re new to this series, here are earlier posts in this series:

  1. Overview of Series
  2. Simple Query
  3. Simple Command

Pipelines

In both the new  Query and Commands handlers wrote in prior posts, there was one thing standing out that really didn’t belong.

Logging

For reference, here was our AddToCartHandler that did some logging at the end of the method.

This really isn’t a concern of our AddToCartHandler.  One way we can separate logging out is by having our Command go through another handler after it’s been executed.  If we think about this a bit more broad, we can take it a step further and create a pipeline for our Command that can go through various handlers prior and after the main AddToCartHandler.

Video

If you prefer, I have a video tutorial that follows this blog post.

Decorators

One way to accomplish this is to use Decorators.  A decorator is nothing more than wrapper around our main handler.

In our example, we are going to use StructureMap.  In your project.json, add the following dependencies.

Next in our Startup.cs we are going to configure StructureMap in the IServiceProvider ConfigureServices(IServiceCollection) method.

The gist is we are going to Decorate/Wrap any ICancellableAsyncRequestHandler<TRequest,TResponse> in a Pipeline<TRequest,TResponse> (which we will create next).

Here is our implementation of the Pipeline<TRequest,TResponse>

It will take the primary request as the first argument in the ctor, and then a array of IPostRequestHandler<TRequest,TResponse>, which we will create next to define our logging handlers.

Log Handler

We now have everything in place to separate the logging from our AddToCartHandler.

All we need to know is create a class that will implement IPostRequestHandler<AddToCart,Unit> and it will be invoked after the AddToCartHandler.

Now we can jump back over to our AddToCartHandler and remove the ILogger and the logging code.

Validation, Authorization, Whatever

Hopefully now you can see that we could extend this to have pre-handlers that may do data validation, authorization or whatever other responsibilities that probably shouldn’t be in your main handler.

Comments

All the source code for this series is available on Github.GitHub

If have another way of creating a pipeline or separating concerns from your handlers, please leave comment or let me know on twitter.


Fat Controller CQRS Diet: Simple Command

Simple CommandThis post is in my Fat Controller CQRS Diet series demonstrate how to thin your controllers by implementing commands and queries using the MediatR library.

For demonstration, I’m converting the MusicStore application that’s using ASP.NET Core MVC.

If you’re new to this series, here are earlier posts in this series:

  1. Overview of Series
  2. Simple Query

Simple Command

A command is request to change the state of our domain.

The first controller action we are going to rewrite is ShoppingCartController.AddToCart

Here is what the method originally looked like this.

As with our simple query, there are a couple things going on here.

  1. MVC is handling the albumId which is pass as an parameter to the method.
  2. We do some data access to get the album out of our EF DbContext
  3. Pass the album to our ShoppingCart
  4. Logging
  5. Return a redirect to the Index action

Extract to Command

What we want to extract are the aspects that MVC is handling.  From the list above it’s the AlbumId being passed the URL/Route and then redirecting to the Index action.

Everything else is our feature, so let’s extract it into a command.

To do so, we need two pieces of information to add to our Request/Command.  The CartId and the AlbumId.

So we will create our Request/Command to contain that data.

Command Handler

Now we can create our handler for this Request/Command.  Basically we are going to extract the majority of the code that was inside our Controller Action and put it into our handler.

You’ll notice we have our constructor take a couple dependencies on our DbContext and the ILogger.

Thin Controller

Now we can jump back to our controller and create our AddToCart Request/Command and send to the Mediator, which will invoke our Handler.

Feature Coupling

We’ve removed coupling of the the MVC framework from our feature code.  We can now create AddToCart Request/Command from other locations and send along to the mediator to have it invoked.

Next

That’s a very simple command endpoint that we moved our logic to a Command Handler using MediatR.

Next up we we will handle a more complex handler.

All the source code for this series is available on Github.GitHub

If anyone has any comments, suggestions or recommendations please leave comment or let me know on twitter.