.NET Domain-Driven Design with C#: Problem - Design - Solution (Programmer to Programmer) (Paperback)

by Tim McCarthy (Author)
Key Phrases: proposal request, construction change directive, template method, Change Order, Unit of Work, Binding Path (more...)

Editorial Reviews

Product Description
As the first technical book of its kind, this unique resource walks you through the process of building a real-world application using Domain-Driven Design implemented in C#. Based on a real application for an existing company, each chapter is broken down into specific modules so that you can identify the problem, decide what solution will provide the best results, and then execute that design to solve the problem. With each chapter, youll build a complete project from beginning to end.

From the Back Cover
.NET Domain-Driven Design with C# Problem Design Solution

As the first technical book of its kind, this unique resource walks you through the process of building a real-world application usingDomain-Driven Design implemented in C#. Based on a real application for an existing company, the project featured throughout the book focuses on the Domain Model and the framework that is being built to support it.

Each chapter is broken down into specific modules so that you can identify the problem, decide what solution will provide the best results, and then execute that design to solve the problem. With each chapter, you?ll build a complete project from beginning to end, offering you indispensable, hands-on practice at creating code that builds applications.

What you will learn from this book

• When, why, and how to use Domain-Driven Design
• How to design and build the initial Domain Model
• What to do to achieve ?Persistence Ignorance?
• Ways to build a Repository framework for the Domain Model
• Techniques for applying TDD to the Domain Model
• How to apply the Model-View-ViewModel Pattern
• How to build a client-side membership system
• What to do to synchronize the client application with the server

Who this book is for
This book is for experienced C# .NET developers who want to improve their techniques for writing applications that perform well and are highly scalable.

Wrox Problem - Design - Solution references give you solid, workable solutions to real-world development problems. Each is devoted to a single application, analyzing every problem, examining relevant design issues, and implementing the ideal solution.

See all Editorial Reviews

Product Details

• Paperback: 432 pages
• Publisher: Wrox (April 28, 2008)
• Language: English
• ISBN-10: 0470147563
• ISBN-13: 978-0470147566
• Product Dimensions: 9.1 x 7.4 x 1.1 inches
• Shipping Weight: 1.5 pounds (View shipping rates and policies)
• Average Customer Review: 3.6 out of 5 stars See all reviews (5 customer reviews)
• Amazon.com Sales Rank: #81,391 in Books (See Bestsellers in Books)

  Popular in this category: (What's this?)

  #93 in

  Books > Computers & Internet > Programming > Languages & Tools > C#

Customer Reviews

Most Helpful Customer Reviews

9 of 9 people found the following review helpful:

5.0 out of 5 stars Nice reference app for DDD, June 20, 2008

By	David C. Veeneman (Lincolnshire, IL USA) - See all my reviews (REAL NAME)

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#.

3 of 3 people found the following review helpful:

4.0 out of 5 stars Useful, but irritating, July 29, 2008

By	Maltese Falcon (Trondheim, Norway) - See all my reviews

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

1 of 1 people found the following review helpful:

2.0 out of 5 stars Important concepts, but impossible to read..., November 15, 2008

By	FujifilmChris "FujifilmChris" (Atlanta, GA USA) - See all my reviews

I think that too many of us who code for fun and profit get caught up in the Smart Client Anti-pattern way of programming due to limited resources and the trappings of RAD. That is why so many of the concepts presented in the book are so important - using real structure so that if you get hit by a bus, someone can read your code and do something with it.

The problem with this book is that it is unreadable.

When a book's goal is to present logical design, but does so in a completely haphazard fashion. Perhaps I expected more of a logical design from a book that talks about logical design.

I feel like there was another book I should have read before this book - I just don't know what that book is. Reading this material without some other primer and coming away with a real sense of DDD is like watching 'Empire' and having a real sense of the entire Star Wars series.

You get a lot of 'Do This', but not a lot of 'This is what needs to happen, and here is how we get there...' Maybe after a few more reads I will get more out of this book, but they are long, slow, painful reads. Sorry Tim - I know how hard it is to write technical material on this high of a level, but this is very unfun reading...