This post was written for the NCrunch blog. You can find the original here. I once worked at a client site where the technical lead told me not to waste time writing tests. Speed was important and writing tests was a waste of time. Besides the fact that that’s a fallacy (I write code better and faster when I include tests), it also implied I needed his permission to write tests. And it wasn’t a good time for writing tests.

This post was written for the NCrunch blog. You can find the original here. When you first start writing unit tests, all is well and the few tests run in a matter of seconds. After having written hundreds or thousands of tests, running them might take…long. Too long. But when is long too long? How long should your unit tests take to run? And how can we reduce the time it takes, without removing or skipping tests? Why Do We

I’ve sung the praise of TDD/automated testing many times before, but recently encountered an angle I hadn’t considered yet: the importance of automated tests for onboarding. Automated tests have several benefits: if you’re practicing TDD, it generally drives your design in a good direction it provides a safety net for refactoring it can catch bugs it speeds up development it provides some documentation for your code But here’s another advantage: it helps new developers tremendously. In part, because of the

At one of my previous customers, a developer once asked me what I do when a client chooses the quick & dirty solution after being confronted with different options. The story behind it was that some members of the team were frustrated with the technical choices their immediate managers were making. When asked for an analysis of a feature, they would propose a solution that involved clean code, modern standards, tests, etc. In short, the ideal solution. But they would

Continuing this series on CQRS and ES in .NET, we’re now going to focus on Event Handlers. I previously covered: CQRS/ES The Command The Command Handler The Repository The Domain Object If you haven’t read them, I advise you to to so first. Read them in order, because they build upon each other. If you’re already familiar with CQRS and Event Sourcing, you can skip the first one. As you might recall, when we modify an aggregate, it stores pending

If you haven’t read the previous posts in this series, you might want to check out: CQRS/ES The Command The Command Handler The Repository In this post, I will look at the Domain Object. So far, we know we can create a Command, give it to the Command Handler, who will use the Repository to retrieve a Domain Object and call the necessary methods on it. After that, the Command Handler will tell the Repository to save the object. Let’s

So far, we’ve covered the CQRS/ES pattern, the Command object, and the Command Handler object. In our last post, we saw that the Command Handler needs a repository to retrieve an object and save it after changes have been made. In this post, I will go into the Repository. The Interface The Repository will be responsible for finding an aggregate and saving it. So our public interface is simple: Let’s take this apart. First, it’s a generic interface, but we’ll

In my previous post, I explained how the Command in (our) CQRS implementation is just a DTO. This means we need to send it somewhere. Meet the CommandHandler. First, let’s define the interface. This will come in handy when we want to use dependency injection later. In my case, I injected the interface into my ASP.NET controllers so I could easily unit test them. The interface is simple: There’s not much to it, except for the fact that we only

Let’s start with the C in CQRS. As you know by now, the C is for “Command.” In our implementation of CQRS/ES, a command will be a basic DTO object. Later, we’ll see that CommandHandlers will take such a command and perform the necessary calls to domain objects. But let’s start simple. As stated, a command will be a simple DTO object, without any special logic. In my case, without any logic at all, except for a constructor. The name

CQRS (command and query responsibility segregation) and ES (event sourcing) are two patterns that are easily explained, but not so easily implemented. The patterns are gaining traction and often come together. But many developers have been trained in a classic CRUD way, and don’t always know where to begin. In this series, I’ll not only cover CQRS/ES abstractly, but I’ll provide real code examples to show you it’s really not very difficult. This first post will, however, focus on the