Applying Domain-Driven Design and Patterns: Using .Net [Hardcover]

I had very hight expecations for this book and when I started reading it I believed it might live up to them. However as I got into it I found it promised much but delivered far too little.

* Pros *

- There are no other books that currently cover DDD with .NET

- Some of the chapters do provide useful content.

- If you are going to be doing DDD then this, plus the book by Eric Evans and the domain driven design Yahoo group will really get you going.

* Cons *

- The early chapters deal with things that are covered better elsewhere such as TDD and refactoring, if you want to understand the two concepts your far better starting going to Robert Martins Agile Priciples development book.

- The really important chapters are on DDD. Take chapter 6 on how to prepare for persistence. Throughout a large part of the chapter the author refers to his own NWorkspace abstraction layer. The layer itself sounds quite good but he doesn't let you download it and doesn't describe in enough detail for you to really get your head around how it works and whether you think its worth having. This leaves you in an odd no mans land, trying to make sense of code examples that refer to classes/interfaces that you cant get your hands on:

IQuery q = new Query(typeof(Order), typeof(OrderSnapshot)

, new string[]{"Id", "OrderNumber", "Customer.Id"

, "Customer.Name"});

q.AddCriterion("Year",year);

result _ws.GetByQuery(q);

- Shorter, more focused, chapters would have made it easier to look things up. In actual fact in a few cases I've thought "Ahh, I'm sure the book has something to say about that" only to find that I couldn't actually find the section that he discussed it in. All in all I think the core chapters (5-8) could be radically improved if they were restructured.

- I'm not alone in thinking that the author keeps bringing up really interesting topics but then moves on to something else without giving you much insight.

- A more focused, less chatty, writing style would have made the book easier to read.

- Glosses over the interesting/difficult parts whilst focussing unnecessary effort on fairly humdrum issues.

- Many of sections are needlessly confusing, making it a frustrating read.

- Contains very few useful code examples, which I personally found surprising.

- Provides very little theory so you'll probably want to read the book by Eric Evans first.

- Many of the sections, including example the parts on AOP/dependency injection, are really just introductions.

- Much of whats discussed in the the earlier chapters really only makes sense in the context of ORM.

- Some of the writing is quite poor and difficult to understand.

- The quality of different parts of the book varies massively, especially when the guest authors are involved.

All in all if you're doing DDD in .NET then you probably will want to buy it but don't expect a masterpiece.

I got very excited just reading the title of this book. Finally, a book that brings DDD into the real world with samples, practical advice and actual implementations. I was determined to extract every ounce of goodness from this book to apply in my professional development career.

I gave the author his space and allowed him the first couple of chapters to do his scene setting. TDD, yes, heard of that. Refactoring another "Hello World", yes, thanks, seen that a million times before. Sadly, the book doesn't really go anywhere from there. The author does a DDD tour but unfortunately does not deliver on its promise of C#-specific goodness. The author's samples are weak, short and fanciful. The author repeatedly asks the reader to "trust him" and "not worry about the details". However, once you get to the end of the book you are sadly lacking in the details that would make any of the book's concepts and samples at all useful.

The only positive thing I can say about this book is that it has breadth. The author is obviously passionate about the topic. Alas, it remains a theoretical and academic discussion, nothing more.

I like this book! The best thing about the book for me is that the author does take you on a journey of design discovery using TDD techniques. Rather than showing you "the only true solution" the author formulates a design then critiques it with the reader, refactors it, and moves on. This approach allows you to really see and understand the refactorings. The writing is passionate, informed and the dialog with the reader enhances understanding. I'm a Java guy but found the C#/.Net stuff sample code clearly understandable. He also uses NUnit (for TDD) and NHibernate (O/R mapping). I'm used to JUnit and Hibernate so no probs there either. If you've been around the block a few times, this book will appeal to you.