Product Description

Applying Domain-Driven Design and Patterns is the first complete, practical guide to leveraging patterns, domain-driven design, and test-driven development in .NET environments. Drawing on seminal work by Martin Fowler and Eric Evans, Jimmy Nilsson shows how to customize real-world architectures for any .NET application. You’ll learn how to prepare domain models for application infrastructure; support business rules; provide persistence support; plan for the presentation layer and UI testing; and design for service orientation or aspect orientation. Nilsson illuminates each principle with clear, well-annotated code examples based on C# 2.0, .NET 2.0, and SQL Server 2005. His examples will be valuable both to C# developers and those working with other .NET languages and databases -- or even with other platforms, such as J2EE.

Product Details

• Amazon Sales Rank: #89561 in Books
• Published on: 2006-05-18
• Original language: English
• Number of items: 1
• Binding: Hardcover
• 576 pages

From the Back Cover

“[This] is a book about design in the .NET world, driven in an agile manner and infused with the products of the enterprise patterns community. [It] shows you how to begin applying such things as TDD, object relational mapping, and DDD to .NET projects...techniques that many developers think are the key to future software development.... As the technology gets more capable and sophisticated, it becomes more important to understand how to use it well. This book is a valuable step toward advancing that understanding.”

–Martin Fowler, author of Refactoring andPatterns of Enterprise Application Architecture

Patterns, Domain-Driven Design (DDD), and Test-Driven Development (TDD) enable architects and developers to create systems that are powerful, robust, and maintainable. Now, there’s a comprehensive, practical guide to leveraging all these techniques primarily in Microsoft .NET environments, but the discussions are just as useful for Java developers.

Drawing on seminal work by Martin Fowler (Patterns of Enterprise Application Architecture) and Eric Evans (Domain-Driven Design), Jimmy Nilsson shows how to create real-world architectures for any .NET application. Nilsson illuminates each principle with clear, well-annotated code examples based on C# 1.1 and 2.0. His examples and discussions will be valuable both to C# developers and those working with other .NET languages and any databases–even with other platforms, such as J2EE. Coverage includes

·        Quick primers on patterns, TDD, and refactoring

·        Using architectural techniques to improve software quality

·        Using domain models to support business rules and validation

·        Applying enterprise patterns to provide persistence support via NHibernate

·        Planning effectively for the presentation layer and UI testing

·        Designing for Dependency Injection, Aspect Orientation, and other new paradigms

About the Author

Jimmy Nilsson owns and runs the Swedish consulting company JNSK AB. He has written numerous technical articles and two books. He has also been training and speaking at conferences, but above everything else, he is a developer with almost 20 years of experience (www.jnsk.se/weblog/).

Customer Reviews

A frustrating read
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.

Theory++, practical--
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.

For the Designer in us all
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.