For students learning in the Microsoft environment, this book is a companion
to the original Design Patterns text tailored to the C#. This book is an
application book, rather than a theoretical one. It is written for students who
want to gain a better understanding of the patterns described in the seminal
design patterns book by Gamma et al. The book's intent is to give students the
confidence and know-how to apply the original 23 patterns identified in the
Gamma book, with all code examples provided in C#.
Table of Contents:
Preface.
1. Introduction.
Why Patterns? Why Design Patterns? Why C#? UML.
Challenges. The Organization of this Book. Welcome to Oozinoz! Summary.
I. INTERFACE PATTERNS.
2. Introducing Interfaces.
Interfaces and Abstract Classes. Interfaces and
Delegates. Interfaces and Properties. Interface Details. Summary. Beyond
Ordinary Interfaces.
3. Adapter.
Adapting to an Interface. Class and Object
Adapters. Adapting Data in .NET. Summary.
4. Facade.
An Ordinary Facade. Refactoring to Facade.
Facades, Utilities, and Demos. Summary.
5. Composite.
An Ordinary Composite. Recursive Behavior in
Composites. Composites, Trees, and Cycles. Composites with Cycles. Consequences
of Cycles. Summary.
6. Bridge.
An Ordinary Abstraction. From Abstraction to
Bridge. Drivers as Bridges. Database Drivers. Summary.
II. RESPONSIBILITY PATTERNS.
7. Introducing Responsibility.
Ordinary Responsibility. Controlling
Responsibility with Accessibility. Summary. Beyond Ordinary Responsibility.
8. Singleton.
Singleton Mechanics. Singletons and Threads.
Recognizing Singleton. Summary.
9. Observer.
C# Support for Observer. Delegate Mechanics. A
Classic Example-Observer in GUIs. Model/View/Controller. Layering. Summary.
10. Mediator.
A Classic Example-GUI Mediators. Relational
Integrity Mediators. Summary.
11. Proxy.
A Simple Proxy. A Data Proxy. Remote Proxies.
Summary.
12. Chain of Responsibility.
An Ordinary Chain of Responsibility. Refactoring
to Chain of Responsibility. Anchoring a Chain. Chain of Responsibility without
Composite. Summary.
13. Flyweight.
Immutability. Extracting the Immutable Part of a
Flyweight. Sharing Flyweights. Summary.
III. CONSTRUCTION PATTERNS.
14. Introducing Construction.
A Few Construction Challenges. Summary. Beyond
Ordinary Construction.
15. Builder.
An Ordinary Builder. Building under Constraints.
A Forgiving Builder. Summary.
16. Factory Method.
A Classic Example-Enumerators. Recognizing
Factory Method. Taking Control of Which Class to Instantiate. Factory Method in
Parallel Hierarchies. Summary.
17. Abstract Factory.
A Classic Example-GUI Kits. Abstract Factories
and Factory Method. Namespaces and Abstract Factories. Summary.
18. Prototype.
Prototypes as Factories. Prototyping with
Clones. Summary.
19. Memento.
A Classic Example-Using Memento for Undo.
Memento Durability. Persisting Mementos across Sessions. Summary.
IV. OPERATION PATTERNS.
20. Introducing Operations.
Operations and Methods. Signatures. Delegates.
Exceptions. Algorithms and Polymorphism. Summary. Beyond Ordinary Operations.
21. Template Method.
A Classic Example-Sorting. Completing an
Algorithm. Template Method Hooks. Refactoring to Template Method. Summary.
22. State.
Modeling States. Refactoring to State. Making
States Constant. Summary.
23. Strategy.
Modeling Strategies. Refactoring to Strategy.
Comparing Strategy and State. Comparing Strategy and Template Method. Summary.
24. Command.
A Classic Example-Menu Commands. Using Command
to Supply a Service. Command Hooks. Command in Relation to Other Patterns.
Summary.
25. Interpreter.
An Interpreter Example. Interpreters, Languages,
and Parsers. Summary.
V. EXTENSION PATTERNS.
26. Introducing Extensions.
Principles of OO Design. The Liskov Substitution
Principle. The Law of Demeter. Removing Code Smells. Beyond Ordinary Extensions.
Summary.
27. Decorator.
A Classic Example-Streams. Function Wrappers.
Decorator in GUIs. Decorator in Relation to Other Patterns. Summary.
28. Iterator.
Ordinary Iteration. Thread-Safe Iteration.
Iterating over a Composite. Summary.
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