Editorial Review:
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.
Cached date: AWS Called=true
You may also be interested in these products:
These categories may also be of interest to you:
Customer Reviews
Average Customer Rating: 
I hope his real apps don't look like this!  2008-08-19
I've read the othere two DDD books (see other reviewers) and apart from Evans (that was a good book) have been quite disappointed. This book I thought would provide a good understanding of how DDD can be used in real-world production quality apps. If that's what you think this book offers, keep looking!! It actually annoys me to no end when authors, especially ones with such distinguished titles as MVP in Solutions Architecture demonstrate such god awful code that should NEVER make it into a production environment. Taking one example (there are a few) ALL the repositories are subject to SQL Injection attacks. The author may argue that it was done for simplicity, well there's a LOT of pages with that code on it and no-mention (unless I missed it - it is rather repeitive; see previous review) of that it shouldn't be used in real-world apps; in anycase parameterised queries could have been used with only a little extra coding.
So from a lets show you how you could/should code a DDD app in .NET it fails on almost every level.
HOWEVER! His discussions on aggregate roots is quite good and the only reason I gave a 2 star and not 1.
Its unfortunate that there are so little books on the market in this important area for .NET. Hopefully someone will provide a decent one with code they would put into an enterprise application not crap sample code that shouldn't be used by anyone!!
Not for beginners, but excellent book!  2008-07-30
The goal of this book is to show how one can apply Domain Driven Design (DDD) techniques to building N-Tier .Net applications, using the iterative development of a construction management application as a running example. In order to benefit most from this book, you must at least have some exposure to DDD concepts, and design patterns such as the Repository, Specification and UnitOfWork patterns. In addition, you must also know some Windows Presentation Foundation (WPF) basics because the author uses this relatively new Microsoft technology but does not provide an introduction to it. You will learn a lot from this book, however. Each of the eleven chapters starts out with a problem description, followed by a proposed design addressing the problems at hand, and conclude with annotated implementation code and a lessons learned summary. Some of the things you will learn from this book include: why is it important to draw distinctions between entity and value objects, what are entity aggregates, how do you handle differently the persisting of objects representing aggregate roots, non-aggregate roots, and collections. If you have not previously heard about the Model-View-ViewModel pattern, how it compares with the Model-View-Controller and Model-View-Presentation patterns, and why it might be a good pattern to use when WPF is the presentation technology, you can learn all about it in this book. What will you not learn from this book? You will not learn how to use or integrate Microsoft's Entity Framework into the implementation of an N-Tier application. Although the author had hoped to show how to do this, he explained in the book why he was unable to. Overall, however, I think the book merits a five star rating.
Useful, but irritating 2008-07-29
I find the book useful in the way it present a design the evolves as the authors attack new parts of the problem area. There are many interesting patterns and ways of dealing with problems that I can see myself using in my own projects.
My main objective is that it can get a bit repetitive. By accident I skipped from the middle of one chapter to the middle of the next. Because of the repetitiveness it took me a while to discover it. At the same time new aspects are constantly introduced so there are still value in the new chapters.
A big annoyance is all the textual errors. It is obvious that cut and paste has been a big part of writing this book, and many times the author has forgotten to update the copied text appriopriately. There is also evidence of the restructuring of the book gone bad, with reference to items not having been introduced yet. It all seems like a bit of a rush job.
Even so, I will give it a pretty high score for the content of the book and the way it can help developers approach their challenges in a good way
Nice reference app for DDD 2008-06-20
I've been playing with Domain Driven Design off-and-on for about a year now. I've read the Evans book (Domain-Driven Design: Tackling Complexity in the Heart of Software), the Nillson book (Applying Domain-Driven Design and Patterns: With Examples in C# and .NET), and the Fowler book (Patterns of Enterprise Application Architecture (The Addison-Wesley Signature Series)), but what I really need is a real-world reference app to put all these concepts together.
That's what Tim McCarthy's book does. It presents an anotated reference application, a real estate construction management application built as a WPF smart client. McCarthy's writing is clear and to-the-point--he simply provides a running commentary on the reference app from a sequence-of-development perspective. He starts with a skeleton and builds out the app from there, discussing his refactorings as he goes. I find this very helpful as a template for developing my own DDD apps.
The reference app is written in C#, as are the book's code snippets. However, since most of the code discussed boils down to .NET calls, even VB users with only limited experience with C# may find it useful. As C# is my language of choice, it did not present any problem for me.
This is a really good book; the best I've bought in a while. I do not hesitate to recommend it to any developer learning DDD in C#.
|
|
