Applying Domain-Driven Design and Patterns: With Examples in C# and .NET

Product Author Bios

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/).

“[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 and Patterns 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

Online Sample Chapter

A Head Start on Domain-Driven Design Patterns

Table of Contents

About the Author     xxv

Forewords     xxvii

Preface: Bridging Gaps     xxxi

Part I: Background

Chapter 1: Values to Value     3

Chapter 2: A Head Start on Patterns     47

Chapter 3: TDD and Refactoring     77

Part II: Applying DDD

Chapter 4: A New Default Architecture     113

Chapter 5: Moving Further with Domain-Driven Design     143

Chapter 6: Preparing for Infrastructure     181

Chapter 7: Let the Rules Rule     229

Part III: Applying PoEAA

Chapter 8: Infrastructure for Persistence     279

Chapter 9: Putting NHibernate into Action     311

Part IV: What’s Next?

Chapter 10: Design Techniques to Embrace     349

Chapter 11: Focus on the UI     407

Part V: Appendices

Appendix A: Other Domain Model Styles     447

Appendix B: Catalog of Discussed Patterns     483

References     493

Index     501

Preface

Bridging Gaps

This bridge replaced a ferry that I took many times as a child. I enjoy very much driving over it even after dozens of times.

On a personal note, my father was on the team that built the highest parts of the bridge.

But beyond these, the main reason is that this book is very much about bridging gaps; bridging gaps between users and developers; bridging gaps between business and software; bridging gaps between logic and storage. Bridging gaps between "DB-guys" and "OO-guys"...

I will refrain from making a joke about the Bridge pattern GoF Design -Patterns. Hey, how geeky can a preface be?

Focus of This Book

Put another way, my vision has been to provide a book that will put Eric Evans' Domain-Driven Design Evans DDD and Martin Fowler's Patterns of Enterprise Application Architecture Fowler PoEAA in context.

DDD might be perceived as a bit abstract. Therefore, more concrete examples are helpful regarding persistence, for example. Mine may be fairly basic, but it is a platform to start from. This book not only explains how to use the patterns, but also how the patterns are used in O/R Mappers, for example.

It has become very clear to me that "one size does not fit all" when it comes to architecture. Having said that, patterns have proven to be general enough to use and reuse in context after context.

The focus isn't on the patterns themselves, but this book uses patterns in every chapter as a tool and language for discussing different design aspects. A nice side effect is that patterns-ignorant readers will also gain some insight and interest into patterns along the way.

That also goes for TDD. Not all developers have become interested in this yet. I think it's especially common in the .NET community that TDD (just as patterns) is considered a niche technique at best, or it might even be totally unknown. Readers will learn how to apply TDD.

Why This Book?

My change of heart started when I read two recent books that inspired me and changed my thinking. First, there was Martin Fowler's Patterns of Enterprise Application Architecture Fowler PoEAA. This book inspired me to give the Domain Model pattern another try after having failed with several earlier attempts.

Then I read Eric Evans' book Domain-Driven Design Evans DDD. This book provided me with insights about how to think and act regarding development with a strong domain focus and with a certain style of how to apply the Domain Model pattern.

Another important influence was all that I learned from teaching my patterns course over a couple of years. As I interacted with students and the material evolved, I had insights myself.

My views of DDD transformed as I worked on an ambitious (though unfortunately unfinished) open source project called Valhalla, which I developed in collaboration with Christoffer Skjoldborg. (Christoffer did by far the most work.)

To summarize all this, I felt that a book that dealt more with application than theory was needed, but one that was based on solid ground, such as the DDD and PoEAA books. "Applying" feels close to my heart because I consider myself a developer above anything else.

Target Audience

• Object-orientation
• .NET or a similar platform
• C# or a similar language
• Relational databases; for example, SQL Server
  

However, interest and enthusiasm will compensate for any lack of prior experience.

I'd like to elaborate on my statement that the target audience is wide. First, we can think about the way we put people into platform boxes. The book should serve .NET people who want a more core-based approach than drag-till-you-drop (if I may use some weak generalizations). Java people should get something out of the discussions and examples of how to combine DDD and O/R Mapping.

I think the chosen language/platform is less and less important, so it feels a little strange to talk about .NET people and Java people. Let's try to describe the target audience by using another dimension. Then I think that the book is for developers, team leaders, and architects.

Choosing yet another dimension, I think there might be something in this book both for intermediate and advanced readers. There's probably also something for beginners.

Organization of This Book

Part I: Background
In this part, we discuss architecture and processes in general terms. There is a lot of emphasis on Domain Models and DDD Evans DDD. We also introduce patterns and TDD. The chapters include the following:

Chapter 1, "Values to Value": This chapter discusses properties of architecture and process to value for creating quality results when it comes to system development. The discussion is influenced by Extreme Programming.

Chapter 2, "A Head Start on Patterns": This chapter focuses on providing examples and discussions about patterns from different families, such as design patterns, architectural patterns and domain patterns.

Chapter 3, "TDD and Refactoring": Chapter 1 talks quite a lot about TDD and refactoring, but in this chapter there is more in-depth coverage with pretty long examples and also different flavors of TDD.

Part II: Applying DDD: In this part, it's time to apply DDD. We also prepare the Domain Model for the infrastructure, and focus quite a lot on rules aspects.

Chapter 4, "A New Default Architecture": This chapter lists a set of requirements of an example application, and a first-try model is created as a start for the coming chapters. A Domain Model-based architecture is used.

Chapter 5, "Moving Further with Domain-Driven Design": The requirements set up in the prior chapter are used in this chapter as the basis for slowly, with TDD, starting to build the Domain Model in a DDD-ish style.

Chapter 6, "Preparing for Infrastructure": Even though we try to push the infrastructure aspects as far off in the future as possible, it's good to think a little bit ahead and prepare the Domain Model for the infrastructure needs. In this chapter, there is a lot of discussion about pros and cons of Persistence Ignorant Domain Models.

Chapter 7, "Let the Rules Rule": This chapter talks about business rules in the form of validation and how a Domain Model-based solution can deal with the need for such rules, connecting back to the requirements

Downloadable Sample Chapter

Download the Sample Chapter related to this title.

Foreword

Download the Foreword file from this book.