设计模式有助于开发人员利用整个软件开发群体的智慧开发健壮的高质量软件。本书是第一部完整的面向c#和．NET程序员的设计模式指导著作。如果您已经基于其他程序设计语言使用了软件设计：模式，那么本书有助于加深读者的理解，增强读者的自信心，并能帮助读者在各种类型的C#工程中使用设计模式。如果读者是一位Microsoft程序员，但是还不熟悉设计模式，那么本书是一本理想的实践入门指导。

Preface

Chapter 1: Introduction

Why Patterns?

Why Design Patterns?

Why C#?

UML

Challenges

The Organization of this Book

Welcome to Oozinoz!

Summary

Part 1: Interface Patterns

Chapter 2: Introducing Interfaces

Interfaces and Abstract Classes

Interfaces and Delegates

Interfaces and Properties

Interface Details

Summary

Beyond Ordinary Interfaces

Chapter 3: Adapter

Adapting to an Interface

Class and Object Adapters

Adapting Data in .NET

Summary

Chapter 4: Facade

An Ordinary Facade

Refactoring to Facade

Facades, Utilities, and Demos

Summary

Chapter 5: Composite

An Ordinary Composite

Recursive Behavior in Composites

Composites, Trees, and Cycles

Composites with Cycles

Consequences of Cycles

Summary

Chapter 6: Bridge

An Ordinary Abstraction

From Abstraction to Bridge

Drivers as Bridges.

Database Drivers

Summary

Part 2: Responsibility Patterns

Chapter 7: Introducing Responsibility

Ordinary Responsibility

Controlling Responsibility with Accessibility

Summary

Beyond Ordinary Responsibility

Chapter 8: Singleton

Singleton Mechanics

Singletons and Threads

Recognizing Singleton

Summary

Chapter 9: Observer

C# Support for Observer

Delegate Mechanics

A Classic Example---Observer in GUIs

Model/View/Controller

Layering

Summary

Chapter 10: Mediator

A Classic Example---GUI Mediators

Relational Integrity Mediators

Summary

Chapter 11: Proxy

A Simple Proxy

A Data Proxy

Remote Proxies

Summary

Chapter 12: Chain of Responsibility

An Ordinary Chain of Responsibility

Refactoring to Chain of Responsibility

Anchoring a Chain

Chain of Responsibility without Composite

Summary

Chapter 13: Flyweight

Immutability

Extracting the Immutable Part of a Flyweight

Sharing Flyweights

Summary

Part 3: Construction :Patterns

Chapter 14: Introducing Construction

A Few Construction Challenges

Summary

Beyond Ordinary Construction

Chapter 15: Builder

An Ordinary Builder

Building under Constraints

A Forgiving Builder

Summary

Chapter 16: Factory Method

A Classic Example Enumerators

Recognizing Factory Method

Taking Control of Which Class to Instantiate

Factory Method in Parallel Hierarchies

Summary

Chapter 17: Abstract Factory

A Classic Example GUI Kits

Abstract Factories and Factory Method

Namespaces and Abstract Factories

Summary

Chapter 18: Prototype

Prototypes as Factories

Prototyping with Clones

Summary

Chapter 19: Memento

A Classic Example Using Memento for Undo

Memento Durability

Persisting Mementos across Sessions

Summary

Part 4: Operation Patterns

Chapter 20: Introducing Operations

Operations and Methods

Signatures

Delegates

Exceptions

Algorithms and Polymorphism

Summary

Beyond Ordinary Operations

Chapter 21: Template Method

A Classic Example--Sorting

Completing an Algorithm

Template Method Hooks

Refactoring to Template Method

Summary

Chapter 22: State

Modeling States

Refactoring to State

Making States Constant

Summary

Chapter 23: Strategy

Modeling Strategies

Refactoring to Strategy

Comparing Strategy and State

Comparing Strategy and Template Method

Summary

Chapter 24: Command

A Classic Example--Menu Commands

Using Command to Supply a Service

Command Hooks

Command in Relation to Other Patterns

Summary

Chapter 25: Interpreter

An Interpreter Example

Interpreters, Languages, and Parsers

Summary

Part 5: Extension Patterns

Chapter 26: Introducing Extensions

Principles of OO Design

The Liskov Substitution Principle

The Law of Demeter

Removing Code Smells

Beyond Ordinary Extensions

Summary

Chapter 27: Decorator

A Classic Example--Streams

Function Wrappers

Decorator in GUIs

Decorator in Relation to Other Patterns

Summary

Chapter 28: Iterator

Ordinary Iteration

Thread-Safe Iteration

Iterating over a Composite

Summary

Chapter 29: Visitor

Visitor Mechanics

An Ordinary Visitor

Visitor Cycles

Visitor Controversy

Summary

Appendix A: Directions

Get the Most Out of This Book

Understand the Classics

Weave Patterns into Your Code

Keep Learning

Appendix B: Solutions

Appendix C: Oozinoz Source

Acquiring and Using the Source

Building the Oozinoz Code

Helping the Oozinoz Code Find Files

Testing the Code with NUnit

Finding Files Yourself

Summary

Appendix D: UML at a Glance

Classes

Class Relationships

Interfaces

Delegates and Events

Objects

States

Glossary

Bibliography,

Index