CQRS: Refactoring Queries without Repositories

Sponsor: Using RabbitMQ or Azure Service Bus in your .NET systems? Well, you could just use their SDKs and roll your own serialization, routing, outbox, retries, and telemetry. I mean, seriously, how hard could it be?

When designing Aggregate Roots do you eager load all navigational properties? Any articles/pointers for practices around this? cc @julielerman @ardalis
— Rahul Nath (@rahulpnath) February 25, 2020

This question posted on Twitter (and the subsequent thread) caught my attention. I had to pipe in with my own opinion on having queries without repositories.

Or don't use an aggregate root for reads and only use for writes. If you generally have low writes, then load the aggregate by eager loading the navigation that you need for the write action
— Derek Comartin (@codeopinion) February 25, 2020

To summarize, the question is about using Aggregate Roots with an ORM like Entity Framework. Should you eager load all navigation properties or alternatively I guess, use lazy loading?

My answer is if you’re only using an aggregate root for commands (to change state) and you generally have a higher read to write ratio, then eager load the navigation properties. As a general rule of thumb.

eShopOnWeb

I recently heard about eShipOnWeb from Steve Smith. It’s a reference application using ASP.NET Core 3.1 using a layered monolithic architecture.

I decided to take a look around and try and refactor a spot that was using a repository for a query.

There is a query to return all of the orders for a signed-in user. It’s pretty simple but is a good example of it using the OrderRepository along with a specification to fetch out the relevant orders. From there it creates a ViewModel that is used in a Razor view.

	using MediatR;
	using Microsoft.eShopWeb.ApplicationCore.Interfaces;
	using Microsoft.eShopWeb.ApplicationCore.Specifications;
	using Microsoft.eShopWeb.Web.ViewModels;
	using System.Collections.Generic;
	using System.Linq;
	using System.Threading;
	using System.Threading.Tasks;

	namespace Microsoft.eShopWeb.Web.Features.MyOrders
	{
	public class GetMyOrdersHandler : IRequestHandler<GetMyOrders, IEnumerable<OrderViewModel>>
	{
	private readonly IOrderRepository _orderRepository;

	public GetMyOrdersHandler(IOrderRepository orderRepository)
	{
	_orderRepository = orderRepository;
	}

	public async Task<IEnumerable<OrderViewModel>> Handle(GetMyOrders request, CancellationToken cancellationToken)
	{
	var specification = new CustomerOrdersWithItemsSpecification(request.UserName);
	var orders = await _orderRepository.ListAsync(specification);

	return orders.Select(o => new OrderViewModel
	{
	OrderDate = o.OrderDate,
	OrderItems = o.OrderItems?.Select(oi => new OrderItemViewModel()
	{
	PictureUrl = oi.ItemOrdered.PictureUri,
	ProductId = oi.ItemOrdered.CatalogItemId,
	ProductName = oi.ItemOrdered.ProductName,
	UnitPrice = oi.UnitPrice,
	Units = oi.Units
	}).ToList(),
	OrderNumber = o.Id,
	ShippingAddress = o.ShipToAddress,
	Total = o.Total()
	});
	}
	}
	}

view raw MyOrders.cs hosted with ❤ by GitHub

Here’s the razor view for reference

	@model IEnumerable<OrderViewModel>
	@{
	ViewData["Title"] = "My Order History";
	}

	<div class="esh-orders">
	<div class="container">
	<h1>@ViewData["Title"]</h1>
	<article class="esh-orders-titles row">
	<section class="esh-orders-title col-xs-2">Order number</section>
	<section class="esh-orders-title col-xs-4">Date</section>
	<section class="esh-orders-title col-xs-2">Total</section>
	<section class="esh-orders-title col-xs-2">Status</section>
	<section class="esh-orders-title col-xs-2"></section>
	</article>
	@if (Model != null && Model.Any())
	{
	@foreach (var item in Model)
	{
	<article class="esh-orders-items row">
	<section class="esh-orders-item col-xs-2">@Html.DisplayFor(modelItem => item.OrderNumber)</section>
	<section class="esh-orders-item col-xs-4">@Html.DisplayFor(modelItem => item.OrderDate)</section>
	<section class="esh-orders-item col-xs-2">$ @Html.DisplayFor(modelItem => item.Total)</section>
	<section class="esh-orders-item col-xs-2">@Html.DisplayFor(modelItem => item.Status)</section>
	<section class="esh-orders-item col-xs-1">
	<a class="esh-orders-link" asp-controller="Order" asp-action="Detail" asp-route-orderId="@item.OrderNumber">Detail</a>
	</section>
	<section class="esh-orders-item col-xs-1">
	@if (item.Status.ToLower() == "submitted")
	{
	<a class="esh-orders-link" asp-controller="Order" asp-action="cancel" asp-route-orderId="@item.OrderNumber">Cancel</a>
	}
	</section>
	</article>
	}
	}
	</div>
	</div>

view raw MyOrders.cshtml hosted with ❤ by GitHub

Looking at the Razor view, you can see that it doesn’t use some of the properties on OrderViewModel. The OrderItems or ShippingAddress properties are never used.

The Repository with the specification is retrieving the entire Order Aggregate Root and eager loading the OrderItems. We’re fetching in a lot of data that we simply aren’t using.

Refactoring Queries without Repositories

The refactor is rather simple. Just remove the repository and instead inject the Entity Framework DbContext (CatalogContext). The second part is creating a separate ViewModel (MyOrdersViewModel ) that only contains the data we need for our Razor view. Then use this new ViewModel as a projection in our EF Query.

	using System;
	using MediatR;
	using System.Collections.Generic;
	using System.Linq;
	using System.Threading;
	using System.Threading.Tasks;
	using Microsoft.AspNetCore.Authorization;
	using Microsoft.AspNetCore.Mvc;
	using Microsoft.EntityFrameworkCore;
	using Microsoft.eShopWeb.Infrastructure.Data;

	namespace Microsoft.eShopWeb.Web.Features.MyOrders
	{
	public class MyOrdersViewModel
	{
	public IEnumerable<OrderSummaryViewModel> Orders { get; set; }
	}

	public class OrderSummaryViewModel
	{
	private const string DEFAULT_STATUS = "Pending";

	public int OrderNumber { get; set; }
	public DateTimeOffset OrderDate { get; set; }
	public decimal Total { get; set; }
	public string Status => DEFAULT_STATUS;
	}

	public class GetMyOrdersHandler : IRequestHandler<GetMyOrders, MyOrdersViewModel>
	{
	private readonly CatalogContext _db;

	public GetMyOrdersHandler(CatalogContext db)
	{
	_db = db;
	}

	public async Task<MyOrdersViewModel> Handle(GetMyOrders request, CancellationToken cancellationToken)
	{
	var result = new MyOrdersViewModel();
	result.Orders = await _db.Orders
	.Include(x => x.OrderItems)
	.Where(x => x.BuyerId == request.UserName)
	.Select(o => new OrderSummaryViewModel
	{
	OrderDate = o.OrderDate,
	OrderNumber = o.Id,
	Total = o.OrderItems.Sum(x => x.Units * x.UnitPrice),
	})
	.ToArrayAsync(cancellationToken: cancellationToken);

	return result;
	}
	}
	}

view raw MyOrders.cs hosted with ❤ by GitHub

Side Notes

In many situations, I prefer to create a SQL Database View that I will create a new class to represent and use that as a DbSet in my DbContext. And most often I have a completely different DbContext for writes vs reads. My Reads DbContext is what will have a model that represents the SQL view. This allows you to do that projection as an SQL View rather than doing the projection in your code.

If you were using a SQL Database View and created an OrderSummary class that was on your DbContext, that now might look like this:

	using System;
	using MediatR;
	using System.Collections.Generic;
	using System.Linq;
	using System.Threading;
	using System.Threading.Tasks;
	using Microsoft.AspNetCore.Authorization;
	using Microsoft.AspNetCore.Mvc;
	using Microsoft.EntityFrameworkCore;
	using Microsoft.eShopWeb.Infrastructure.Data;

	namespace Microsoft.eShopWeb.Web.Features.MyOrders
	{
	public class GetMyOrdersHandler : IRequestHandler<GetMyOrders, MyOrdersViewModel>
	{
	private readonly CatalogContext _db;

	public GetMyOrdersHandler(CatalogContext db)
	{
	_db = db;
	}

	public async Task<MyOrdersViewModel> Handle(GetMyOrders request, CancellationToken cancellationToken)
	{
	var result = new MyOrdersViewModel();
	result.Orders = await _db.OrderSummaries
	.Where(x => x.BuyerId == request.UserName)
	.Select(o => new OrderSummaryViewModel
	{
	OrderDate = o.OrderDate,
	OrderNumber = o.Id,
	Total = o.Total,
	})
	.ToArrayAsync(cancellationToken: cancellationToken);

	return result;
	}
	}
	}

view raw view.cs hosted with ❤ by GitHub

Live Coding Session

I did a live coding session on my YouTube and Twitch channels. You can check out the recording here of doing this exact refactor.

GitHub

If you want to take a look a the full sample, you can also find my refactor changes on my fork of eShipOnWeb on GitHub.

Links

Follow @CodeOpinion