Fat Controller CQRS Diet: Simple Command

Sponsor: Do you build complex software systems? See how NServiceBus makes it easier to design, build, and manage software systems that use message queues to achieve loose coupling. Get started for free.

This 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:

Simple Command

Fat Controller CQRS Diet | Part 2 Simple Command (https://www.youtube.com/watch?v=2d-jTjmbkVU)

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.

	public async Task<IActionResult> AddToCart(int id, CancellationToken requestAborted)
	{
	// Retrieve the album from the database
	var addedAlbum = await DbContext.Albums
	.SingleAsync(album => album.AlbumId == id);

	// Add it to the shopping cart
	var cart = ShoppingCart.GetCart(DbContext, HttpContext);

	await cart.AddToCart(addedAlbum);

	await DbContext.SaveChangesAsync(requestAborted);
	_logger.LogInformation("Album {albumId} was added to the cart.", addedAlbum.AlbumId);

	// Go back to the main store page for more shopping
	return RedirectToAction("Index");
	}

view raw ShoppingCartController.cs hosted with ❤ by GitHub

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

MVC is handling the albumId which is pass as an parameter to the method.
We do some data access to get the album out of our EF DbContext
Pass the album to our ShoppingCart
Logging
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.

	public class AddToCart : ICancellableAsyncRequest<Unit>
	{
	public string CartId { get; }
	public int AlbumId { get; }

	public AddToCart(string cartId, int albumId)
	{
	CartId = cartId;
	AlbumId = albumId;
	}
	}

view raw AddToCart.cs hosted with ❤ by GitHub

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.

	public class AddToCartHandler : ICancellableAsyncRequestHandler<AddToCart, Unit>
	{
	private readonly MusicStoreContext _dbContext;
	private readonly ILogger<ShoppingCartController> _logger;

	public AddToCartHandler(MusicStoreContext dbContext, ILogger<ShoppingCartController> logger)
	{
	_dbContext = dbContext;
	_logger = logger;
	}

	public async Task<Unit> Handle(AddToCart message, CancellationToken cancellationToken)
	{
	// Retrieve the album from the database
	var addedAlbum = await _dbContext.Albums
	.SingleAsync(album => album.AlbumId == message.AlbumId, cancellationToken);

	// Add it to the shopping cart
	var cart = Models.ShoppingCart.GetCart(_dbContext, message.CartId);

	await cart.AddToCart(addedAlbum);

	await _dbContext.SaveChangesAsync(cancellationToken);
	_logger.LogInformation("Album {albumId} was added to the cart.", addedAlbum.AlbumId);

	return Unit.Value;
	}
	}

view raw AddToCartHandler.cs hosted with ❤ by GitHub

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.

	public async Task<IActionResult> AddToCart(int id, CancellationToken requestAborted)
	{
	var cartId = ShoppingCart.GetCartId(HttpContext);
	var cmd = new AddToCart(cartId, id);
	await _mediator.SendAsync(cmd, requestAborted);

	// Go back to the main store page for more shopping
	return RedirectToAction("Index");
	}

view raw ShoppingCartController.cs hosted with ❤ by GitHub

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.

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.

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

Follow @codeopinion

4 thoughts on “Fat Controller CQRS Diet: Simple Command”

Paul Wheeler November 11, 2016 at 11:08 am


Neat, I didn’t know about the “CancellationToken requestAborted” MVC feature!
1. Derek Comartin November 11, 2016 at 11:29 am
  
  
  Yes, and if you use MediatR, you can use the ICancellableAsyncRequestHandler and have your handler accept it. Thus, pass it thru to whatever else can use it like EF.
Pingback: Fat Controller CQRS Diet: Trade-offs - CodeOpinion
Pingback: Fat Controller CQRS Diet - CodeOpinion