.Net Domain-Driven Design With C#: Problem-Design-Solution

by Tim McCarthy

This first technical title of its kind, this is a revolutionary book for the object oriented developer. It takes the reader through the intense process of building a real-world application using Domain-Driven Design principles implemented in C# 3.0 (.NET Framework 3.5). The reader is introduced to a business domain of a real-world Construction Administration application for an architecture firm. The application is ma critical, legacy MS Access application that has outgrown MS Access and is ready to become a full-fledged enterprise application. In each chapter, the relevant part of the domain is modeled out via diagrams and code. The application is built using C#, Windows Presentation Foundation, and other Microsoft technologies and best practices. The main focus of the book is on designing and implementing the domain model and all of the supporting patterns and framework that are built in support of the domain model. The emphasis is on these theories in action through the working application, not on the tools used. The main goal is to show how to take a set of requirements and user scenarios and apply Domain-Driven Design principles to the requirements in order to create a domain model that satisfies both the user requirements and the system requirements.  Various patterns are introduced along the way in order to aid with certain activities such as adapting the domain model to the user interface, synchronizing data between the client and the server, validation, mapping, etc. Although this particular application is a WPF application, most of the design patterns introduced and applied in the book can be used on other types of applications, such as web applications, web services, etc.

With the Problem-Design-Solution promise and approach, the chapters are broken down into their own modules where the intent is to take the reader through the process from beginning to end while building a complete project with each chapter module. Each chapter establishes the problem, what the reader wants to do, and why it is important, and then what factors and restrictions need to be taken into account. Next the chapter covers how the programmer will solve the problem with an adequate solution that will provide only the best results. Finally, the developer produces code and other materials to better realize the design and solution to the problem. This part of the chapter is where the reader gets hands-on practice at creating code that builds applications.

Genres: Programming, Technology, Software

432 pages, Paperback

First published January 1, 2008

Reviews

[Pawel Wujczyk · Rating 1 out of 5]

Book describes creating the application, but more it is focusing on adding new functionalities than to describe technical concept. So after first business module, next are pretty much the same and it doesn't make sense to read them. What is more, author describe code so if you generally understand c# and aren't interested how implementation of constructor of Address class looks like you don't have a lot to read. Basically from middle of the book I just fly it over. Additionally not every code is included :-D. The most interesting (for me) part - synchronization server - client were committed.

[Johnny · Rating 1 out of 5]

I had high expectations on a book that finally would explain the real-world approach on Domain-Driven Design. Domain-Driven Design: Tackling Complexity in the Heart of Software by Eric Evans has great ideas encapsulated in a boring book and Implementing Domain-Driven Design by Vaughn Vernon wasn’t any better. Despite the title the implementing part was hard to find and the book yet another academic approach.

This book is different. Unfortunately, not in a way that makes it a great book. Tim McCarthy builds an application using DDD and you can see code over code. The book is great on showing code, but it fails flat on explaining the why behind the code. Is this the DDD approach? Or is it a way that proved to be working? Or is it simply the first thing that McCarthy tried? The lack of explaining why he is solving the problem the way he does reduces the value of the book for me tremendous. If I need to build the same application I can read a solution. However, should I need to build something else I have no idea on how I should proceed.

The errors don’t help to understand the concept and without the errata you will lose a lot of time with (sometimes) fundamental bugs. If you want to read the book, then get the errata first.

[Curtis · Rating 3 out of 5]

Based on a lot of great stuff, but wasn't what I was looking for.

It was a good example of a custom Repository/Entity framework.