Design patterns in C# /
Saved in:
| Author / Creator: | Metsker, Steven John. |
|---|---|
| Imprint: | Boston : Addison-Wesley, c2004. |
| Description: | xvii, 456 p. : ill. ; 24 cm. |
| Language: | English |
| Series: | The software patterns series Software patterns series. |
| Subject: | |
| Format: | Print Book |
| URL for this record: | http://pi.lib.uchicago.edu/1001/cat/bib/5642766 |
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. FacadeAn 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. BuilderAn 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
- lV. Extension Patterns
- 26. Introducing Extensions
- Principles of OO Design
- The Liskov Substitution Principle
- The Law of Demeter
- Remov
