C#设计模式（影印版）

　　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

　　.

　　    设计模式有助于开发人员利用整个软件开发群体的智慧开发健壮的高质量软件。《C#设计模式（影印版）》是第一部完整的面向C#和.NET程序员的设计模式指导著作。
　　    Steven John Metsker解释了用C#作为面向对象编程语言时，如何利用设计模式来创建简洁的代码，与此同时，还能有效地利用内容广泛的Microsoft.NET框架类库。
　　    针对所有23个经典的“四个小姐”（Gang of Four）设计模式，Metsker提供了详细的代码实例，这些代码实例使用了C#和.NET框架，同时提供了有助于快速掌握相关技巧的程序设计习题。这些习题广泛地使用了UML标准表示法的基础上学习掌握相关技能。
　　    如果读者已经基于其他程序设计语言使用了软件设计模式，那么本书有助于加深读者的理解，增加读者的自信心，并能帮助读者在各种类型的C#工程中使用设计模式。如果读者是一位Microsoft程序员，但是还不熟悉设计模式，那么本书是一本理想的实践入门指导。