Hands-On Domain-Driven Design with .NET Core: Tackling complexity in the heart of software by putting DDD principles into practice

by Alexey Zimarev

Solve complex business problems by understanding users better, finding the right problem to solve, and building lean event-driven systems to give your customers what they really wantKey FeaturesApply DDD principles using modern tools such as EventStorming, Event Sourcing, and CQRSLearn how DDD applies directly to various architectural styles such as REST, reactive systems, and microservicesEmpower teams to work flexibly with improved services and decoupled interactionsBook DescriptionDevelopers across the world are rapidly adopting DDD principles to deliver powerful results when writing software that deals with complex business requirements. This book will guide you in involving business stakeholders when choosing the software you are planning to build for them. By figuring out the temporal nature of behavior-driven domain models, you will be able to build leaner, more agile, and modular systems.You'll begin by uncovering domain complexity and learn how to capture the behavioral aspects of the domain language. You will then learn about EventStorming and advance to creating a new project in .NET Core 3.1; you'll also and write some code to transfer your events from sticky notes to C#. The book will show you how to use aggregates to handle commands and produce events. As you progress, you'll get to grips with Bounded Contexts, Context Map, Event Sourcing, and CQRS. After translating domain models into executable C# code, you learn some useful front-end related patterns with a sample application using Vue.js. In addition to this, you'll learn how to refactor your code and cover event versioning and migration essentials.By the end of this DDD book, you will have gained the confidence to implement the DDD approach in your organization and be able to explore new techniques that complement what you've learned from the book.What you will learnDiscover and resolve domain complexity together with business stakeholdersAvoid common pitfalls when creating the domain modelStudy the concept of Bounded Context and aggregateDesign and build temporal models based on behavior and not only dataExplore benefits and drawbacks of Event SourcingGet acquainted with CQRS and to-the-point read models with projectionsUnderstand how a task-based UI conforms to DDD principlesWho this book is forThis book is for .NET developers who have an intermediate level understanding of C#, and for those who seek to deliver value, not just write code. Intermediate level of competence in JavaScript will be helpful to follow the UI examples. First chapters of the book are mostly language-agnostic and can benefit anyone who wants to learn more about DDD and event sourcing. Table of ContentsWhy Domain-Driven Design Language and Context EventStorming Designing the Model Implementing the Model Acting with Commands Consistency Boundary Aggregate The read-sideEvent SourcingProjectionsBounded ContextSplitting the System

Genres: Programming, Software, Coding, Technology, Computer Science, Architecture, Nonfiction

448 pages, Kindle Edition

Published April 30, 2019

Reviews

[سامح دعبس · Rating 3 out of 5]

I believe you should have some background about DDD before reading this book, it doesn't cover all the topics of DDD, and the "hands-on" it has are mainly focused on CQRS+Event Sourcing, which is not what I was expecting from a book with this title.
I enjoyed the theoretical parts of the book more than the code, which starts hard from the beginning to implement Event Sourcing!
The best things in the book are the directions or references it gave me to other topics that I should be aware of during my journey in DDD, like Event Storming and Event Modeling.

[Brian Richardson · Rating 5 out of 5]

Very Practical

Clever engineering overall. I've adopted the DDD implementation used in this book for my own projects. Exposes you to useful technologies like document databases and a specialized event store. Event Sourcing is a very useful approach to DDD and a good introduction is given in this book. Source code is available online to complement the highlighted sections in the book, but may take a little effort to get running correctly.

[Mikhail Filatov · Rating 2 out of 5]

This book title is misleading - while the author is repeating "Domain model', "Bounded context" and other DDD terms on every page this book is about Event Sourcing/CQRS.
It starts with "Event storming" - a technique to collect events - and goes from events to events to events. And it's mostly Kool-aid about Event sourcing while any sane person reading this book would wonder, why do you need so much code to create a simple app for publishing an ad.

[Victor · Rating 4 out of 5]

This is a practical read on DDD, CQRS and Event Sourcing. I really like the fact that it focuses on an example domain (classified adds) and goes from design to implementation. The domain is complex enough to showcase many of the principles and patterns of DDD. It shows how you can use Big Picture EventStorming to better understand the domain and then Design-level EventStorming in order to design the model. A big chunk of the book then shows how to actually implement the model.

I think it focuses on the tactical patterns of DDD. The last two chapters briefly cover Bounded Contexts, UI and integrating Bounded Contexts. I would have liked to see more details and examples on these topics.

There is an accompanying github repo that contains the source code. This is a big plus, since you can clone it and play with the sample.

The book could have used a bit more proofreading. There's a fair amount of typos, cases where the text explanations and the code snippets don't match, a couple of duplicate pages, referencing things that have not been covered yet or references to the wrong chapter. Also, I don't understand why the last chapter is not part of the book, but available to download as a pdf. I like reading on an e-book reader and this made it hard for me to do that.

In summary, this book does what it says in the title: it shows you how to put DDD principles into practice. Its main differentiator is the fact that the examples cover a single domain. This makes it easy to read and grasp the concepts explained.

[Waldemar Mękal · Rating 4 out of 5]

Definitely worth reading.

In short, I would say it's state of art in DDD at 2020. It nicely provides some heuristics when to use DDD based on Cynefin. It shows how to pragmatically approach DDD with Event Storming: Big Picture & Design Level - how to understand the domain and convert it to the code. This is something I missed in the classic books (Evans & Vernon), they walked very lightly over the topic of getting and understanding requirements - it was just "talk with domain experts". It dicusses also Domain Events, CQRS and Event sourcing, which appeared later to classic Blue Book.

So, I really enjoyed reading the book and found some little gems, even I had quite good understanding of DDD before reading this book.

The book has one slightly irritating defect - it looks like it didn't went through the final reading. There are mistakes in listings, in chapter about aggregates there are 5 copy-paste pages from chapter about entities, there are incorrect references to other chapters (like they were re-ordered), little glitches.

If not that, I would give it 5 start, because the content of the book is fantastic.

[Daniel Wellner · Rating 4 out of 5]

Excellent hands-on book about implementing various DDD patterns properly in .NET Core. I really enjoyed both the theoretical parts as well as the well explained example code and even though I have previous experience in both DDD and .NET Core, I did gain lots of new learnings on both subjects.

The book often guides you towards doing things in a somewhat suboptimal way first, allowing you to discover problems for yourself and then continues to improve the examples in order to solve those problems.

I did not use the online code but instead worked through the book by recreating the sample app from scratch, skipping only the postgres -parts. It took me probably around 30 hours to work though the whole thing, but I felt it was worth it, as a lot of the aha moments hit me through working on the various details.

[Tomas Herceg · Rating 4 out of 5]

Quite nice practical insights in DDD for .NET developers.
The first chapters with theory were very well written and explained, however the practical solutions were sometimes presented without deeper reasoning. For example, the value objects could be structs (which would solve equality issues), the Id types could be generic and so on. I understand that many thingshad to be simplified, but I would appreciate more side notes (hey, you can do this in real-world app).
Also, some points that would be interesting to discuss (anemic model) were touched only very briefly, or presented just as facts (Fowler said it’s bad so it’s bad).

[Michiel · Rating 3 out of 5]

This book is a great introduction into DDD, CQRS and Event Sourcing. It is practical, clear and a nice read.

I do have some comments though. The chapters in the start look like they are reordered last minute. Therefore some paragraphs seem out of order. I also do not really like the mix of concepts and C# examples. I would have opted to split those in a more conceptual part and an example part. The DotNet Core in the title seems out of place, although the examples are in C#, the book can easily be read and useful for Java people.

[Andrei Tarutin]

The book is awesome. I like it a lot, for me the most valuable part is that apart from giving you a lot of theory it gives you a lot of examples and finally, at the end of the book you have complete project implemented using ddd approach from the very beginning. It teaches you how to implement DDD approach in .NET using C#. I personally has some questions before reading it. My experience is about 20 years of coding and I've been meeting different cases where I didn't know what would be the best way. This book helped me to solve some of puzzles.

[Ahmad hosseini · Rating 4 out of 5]

A good book to learn about the DDD implementation, not its concepts!

Author focused on DDD implementation and challenges you might face. He have explained about DDD concepts so little and in brief.
Explaining Event Storming method is one of the best thing about the book. Author explains Event Storming method very well.
Books includes so much codes and sometimes they are so complex. So having enough experience in c# is necessary to understand codes.

[Marcin Świerczyński · Rating 5 out of 5]

I need to say, I have nothing to do with .Net. I'm a JVM developer. Despite this, the book was recommended to me by one of DDD gurus.

And I enjoyed it a lot! It's easy to read, going straight to the point, while still covering most of the crucial topics.

Highly recommended!

[Krzysztof · Rating 4 out of 5]

Really decent book, but I think it ends too early. I've just finished it, and I can't stop thinking that there is so much more to say about DDD.

Anyway, highly recommended. Especially if you are looking for a practical book about the subject with examples in .NET.

[Iwan Cwetanow · Rating 3 out of 5]

Doesn't really touch much of the concepts of DDD, instead the book is focused more on CQRS and event sourcing. Also from the examples I get the feeling that the whole system that is built is a bunch of static extension methods and switch cases

[Jordi Ruiz · Rating 3 out of 5]

It is a good book, however I think the references to some chapters are wrong and I think the author rush a little bit to finish the book. The last part of the book, bounded context, needs some examples of communication between them.

[Maciej Pakulski · Rating 4 out of 5]

Generally, quite an ineresting good book.
Nice examples of how DDD can be used to create a working solution.
The big disadvantage, IMHO, is that the topic of "Bounded Context" is barely touched.

[Sajjad Raihan]

good book