目录
Preface
Acknowledgments
Part I Object-Oriented Programming in C#
Chapter 1 What Am Design Patterns?
Defining Design Patterns
The Learning Process
Studying Design Patterns
Notes on Object-Oriented Approaches
C# Design Patterns
How This Book Is Organized
Chapter 2 Syntax of the O# Language
Data Types
Converting between Numbers and Strings
Declaring Multiple Variables
Numeric Constants
Character Constants
Variables
Declaring Variables as You Use Them
Multiple Equals Signs for Initialization
A Simple C# Program
Arithmetic Operators
Increment and Decrement Operators
Combining Arithmetic and Assignment Statements
Making Decisions in C#
Comparison Operators
Combining Conditions
The Most Common Mistake
The Switch Statement
C# Comments
The Ornery Ternary Operator
Looping Statements in C#
The While Loop
The Do-While Statement
The For Loop
Declaring Variables as Needed in For Loops
Commas in For Loop Statements
How C# Differs from C
How C# Differs from Java
Summary
Chapter 3 Writing Windows C# Programs
Objects in C#
Managed Languages and Garbage Collection
Classes and Namespaces in C#
Building a C# Application
The Simplest Window Program in C#
Windows Controls
Labels
TextBox
CheckBox
Buttons
Radio Buttons
ListBoxes and ComboBoxes
The Items Collection
Menus
ToolTips
The Windows Controls Program
Summary
Programs on the CD-ROM
Chapter 4 Using C/asses and Objects in C#
What Do We Use Classes For?
A Simple Temperature Conversion Program
Building a Temperature Class
Converting to Kelvin
Putting the Decisions into the Temperature Class
Using Classes for Format and Value Conversion
Handling Unreasonable Values
A String Tokenizer Class
Classes as Objects
Class Containment
Initialization
Classes and Properties
Programming Style in C#
Delegates
Indexers
Operator Overloading
Summary
Programs on the CD-ROM
Chapter 5 Inheritance
Constructors
Drawing and Graphics in C#
Using Inheritance
Namespaces
Creating a Square from a Rectangle
Public, Private, and Protected
Overloading
Virtual and Override Keywords
Overriding Methods in Derived Classes
Replacing Methods Using New
Overriding Windows Controls
Interfaces
Abstract Classes
Comparing Interfaces and Abstract Classes
Summary
Programs on the CD-ROM
Chapter 6 UML Diagrams
Inheritance
Interfaces
Composition
Annotation
WithClass UML Diagrams
C# Project Files
Chapter 7 Arrays, Files, and Exceptions in C#
Arrays
Collection Objects
ArrayLists
Hasbtables
SortedLists
Exceptions
Multiple Exceptions
Throwing Exceptions
File Handling
The File Object
Reading a Text File
Writing a Text File
Exceptions in File Handling
Testing for End of File
A csFile Class
Program on the CD-ROM
Part 2 Creational Patterns
Chapter 8 The Simple Factory Pattern
How a Simple Factory Works
Sample Code
The Two Derived Classes
Building the Simple Factory
Using the Factory
Factory Patterns in Math Computation
Summary
Thought Questions
Programs on the CD-ROM
Chapter 9 The Factory Method
The Swimmer Class
The Events Classes
StraightSeeding
CircleSeeding
Our Seeding Program
Other Factories
When to Use a Factory Method
Thought Question
Program on the CD-ROM
Chapter 10 The Abstract Factory Pattern
A GardenMaker Factory
The PictureBox
Handling the RadioButton
and Button Events
Adding More Classes
Consequences of Abstract Factory
Thought Question
Program on the CD-ROM
Chapter 11 The Singleton Pattern
Creating Singleton Using a Static Method
Exceptions and Instances
Throwing the Exception
Creating an Instance of the Class
Providing a Global Point of Access to a Singleton
Other Consequences of the Singleton Pattern
Programs on the CD-ROM
Chapter 12 The Builder Pattern
An Investment Tracker
The Stock Factory
The CheckChoice Class
The ListboxChoice Class
Using the Items Collection in the ListBox Control
Plotting the Data
The Final Choice
Consequences of the Builder Pattern
Thought Questions
Program on the CD-ROM
Chapter 13 The Prototype Pattern
Cloning in C#
Using the Prototype
Cloning the Class
Using the Prototype Pattern
Dissimilar Classes with the Same Interface
Prototype Managers
Consequences of the Prototype Pattern
Thought Question
Programs on the CD-ROM
Summary of Creational Patterns
Part 3 Structural Patterns
Chapter 14 The Adapter Pattern
Moving Data between Lists
Making an Adapter
Using the DataGrid
Detecting Row Selection
Using a TreeView
The Class Adapter
Two-Way Adapters
Object versus Class Adapters in C#
Pluggable Adapters
Thought Question
Programs on the CD-ROM
Chapter 15 The Bridge Pattern
The Bridger Interface
The VisList Classes
The Class Diagram
Extending the Bridge
Windows Forms as Bridges
Consequences of the Bridge Pattern
Thought Question
Programs on the CD-ROM
Chapter 16 The Composite Pattern
An Implementation of a Composite
Computing Salaries
The Employee Classes
The Boss Class
Building the Employee Tree
Self-Promotion
Doubly Linked Lists
Consequences of the Composite Pattern
A Simple Composite
Composites in .NET
Other Implementation Issues
Thought Questions
Programs on the CD-ROM
Chapter 17 The Decorator Pattern
Decorating a CoolButton
Handling Events in a Decorator
Layout Considerations
Control Size and Position
Multiple Decorators
Nonvisual Decorators
Decorators, Adapters, and Composites
Consequences of the Decorator Pattern
Thought Questions
Programs on the CD-ROM
Chapter 18 The Facade Pattern
What Is a Database?
Getting Data Out of Databases
Kinds of Databases
ODBC
Database Structure
Using ADO.NET
Connecting to a Database
Reading Data [rom a Database Table
Executing a Query
Deleting the Contents of a Table
Adding Rows to Database Tables Using ADO.NET
Building the Facade Classes
Building the Price Query
Making the ADO.NET Facade
The DBTable Class
Creating Classes for Each Table
Building the Price Table
Loading the Database Tables
The Final Application
What Constitutes the Facade?
Consequences of the Facade
Thought Question
Program on the CD-ROM
Chapter 19 The Flyweight Pattern
Discussion
Example Code
The Class Diagram
Selecting a Folder
Handling the Mouse and Paint Events
Flyweight Uses in C#
Sharable Objects
Copy-on-Write Objects
Thought Question
Program on the CD-ROM
Chapter 20 The Proxy Pattern
Sample Code
Proxies in C#
Copy-on-Write
Comparison with Related Patterns
Thought Question
Program on the CD-ROM
Summary of Structural Patterns
Part 4 Behavioral Patterns
Chapter 21 Chain of Responsibility
Applicability
Sample Code
ListBoxes
Programming a Help System
Receiving the Help Command
A Chain or a Tree?
Kinds of Requests
Examples in C#
The Chain of Responsibility
Thought Question
Programs on the CD-ROM
Chapter 22 The Command Pattern
Motivation
Command Objects
Building Command Objects
Consequences of the Command Pattern
The CommandHolder Interface
Providing Undo
Thought Questions
Programs on the CD-ROM
Chapter 23 The Interpreter Pattern
Motivation
Applicability
A Simple Report Example
Interpreting the Language
Objects Used in Parsing
Reducing the Parsed Stack
Implementing the Interpreter Pattern
The Syntax Tree
Consequences of the Interpreter Pattern
Thought Question
Program on the CD-ROM
Chapter 24 The Iterator Pattern
Motivation
Sample Iterator Code
Fetching an Iterator
Filtered Iterators
The Filtered Iterator
Keeping Track of the Clubs
Consequences of the Iterator Pattern
Programs on the CD-ROM
Chapter 25 The Mediator Pattern
An Example System
Interactions between Controls
Sample Code
Initialization of the System
Mediators and Command Objects
Consequences of the Mediator Pattern
Single Interface Mediators
Implementation Issues
Program on the CD-ROM
Chapter 26 The Memento Pattern
Motivation
Implementation
Sample Code
A Cautionary Note
Command Objects in the User Interface
Handling Mouse and Paint Events
Consequences of the Memento
Thought Question
Program on the CD-ROM
Chapter 27 The Observer Pattern
Watching Colors Change
The Message to the Media
Consequences of the Observer Pattern
Program on the CD-ROM
Chapter 28 The State Pattern
Sample Code
Switching between States
How the Mediator Interacts with the StateManager
The ComdToolBarButton
Handling the Fill State
Handling the Undo List
The VisRectangle and VisCircle Classes
Mediators and the God Class
Consequences of the State Pattern
State Transitions
Thought Questions
Program on the CD-ROM
Chapter 29 The Strategy Pattern
Motivation
Sample Code
The Context
The Program Commands
The Line and Bar Graph Strategies
Drawing Plots in C#
Making Bar Plots
Making Line Plots
Consequences of the Strategy Pattern
Program on the CD-ROM
Chapter 30 The Template Method Pattern
Motivation
Kinds of Methods in a Template Class
Sample Code
Drawing a Standard Triangle
Drawing an Isosceles Triangle
The Triangle Drawing Program
Templates and Callbacks
Summary and Consequences
Programs on the CD-ROM
Chapter 31 The Visitor Pattern
Motivation
When to Use the Visitor Pattern
Sample Code
Visiting the Classes
Visiting Several Classes
Bosses Are Employees, Too
Catch-All Operations with Visitors
Double Dispatching
Why Are We Doing This?
Traversing a Series of Classes
Consequences of the Visitor Pattern
Thought Question
Program on the CD-ROM
Bibliography
Index
前言
This is a practical book that tells you how to write C# programs using some of the most common design patterns. It also serves as a quick introduction to programming in the new C# language. The pattern discussions are structured as a series of short chapters, each describing a design pattern and giving one or more complete working, visual example programs that use that pattern. Each chapter also includes UML diagrams illustrating how the classes interact.
This book is not a "companion" book to the well-known Design Patterns text by the "Gang of Four." Instead, it is a tutorial for people who want to learn what design patterns are about and how to use them in their work. You do not have to have read Design Patterns to read this book, but when you are done here, you may well want to read or reread it to gain additional insights.
In this book, you will learn that design patterns are frequently used ways of organizing objects in your programs to make them easier to write and modify. You'll also see that by familiarizing yourself with them, you've gained some valuable vocabulary for discussing how your programs are constructed.
People come to appreciate design patterns in different ways--from the highly theoretical to the intensely practical--and when they finally see the great power of these patterns, an "Aha!" moment occurs. Usually this is the moment when you discover how that pattern can help you in your work.
In this book, we try to help you form that conceptual idea, or gestalt, by describing the pattern in as many ways as possible. The book is organized into six main sections: an introductory description, an introduction to C#, and descriptions of patterns that are grouped as creational, structural, and behavioral.
For each pattern, we start with a brief verbal description and then build simple example programs. Each of these examples is a visual program that you can run and examine to make the pattern as concrete a concept as possible. All of the example programs and their variations are on the companion CD-ROM, where you run them, change them, and see how the variations you create work.
Since each of the examples consists of a number of C# files for each of the classes we use in that example, we provide a C# project file for each example and place each example in a separate subdirectory to prevent any confusion. This book assumes you have and will be using a copy of Visual Studio. NET, which comes in several versions. We used the Professional Edition in developing the code samples.
If you leaf through the book, you'll see screenshots of the programs we developed to illustrate the design patterns, providing yet another way to reinforce your learning of these patterns. In addition, you'll see UML diagrams of these programs, illustrating the interactions between classes in yet another way. UML diagrams are just simple box-and-arrow illustrations of classes and their inheritance structure, where arrows point to parent classes, and dotted arrows
point to interfaces. And if you're not yet familiar with UML, we provide a simple introduction in the second chapter. All of the diagrams were produced using WithClass 2000, and a demonstration version of that program is included on the CD-ROM.
When you finish this book, you'll be comfortable with the basics of design patterns and will be able to start using them in your day-to-day C# programming work.
James W. Cooper
Nantucket, MA
Wilton, CT
Kona, HI