|
C# Design Patterns: A Tutorial
This is a practical book that explains how to write C# programs using some of the most common design patterns. With the release of C# and Visual Studio .NET, there is a new interest in the Microsoft development community in some of the OO world's key tools, such as UML and Design Patterns, which they had neglected before. The book covers every pattern
identified in Gamma et al's Design Patterns which can be executed in C#. For each pattern, it starts with a brief verbal description, and then builds simple example programs. Each of these examples is a visual program that can be run and examined to make the pattern as concrete a concept as possible. All of the examples will be on the companion CD. The emphasis is on the practical ways to use these patterns to ease the developer's day to day work. This book should be well timed for the growing number of developers who have learned the basics of C#, and now want information on how to get the most out of C# in their real-world application development.
Contents:
Preface
Acknowledgments
I
OBJECT-ORIENTED PROGRAMMING IN C#
1
What Are Design Patterns? Defining Design Patterns
The Learning Process
Studying Design Patterns
Notes on Object-Oriented Approaches
C# Design Patterns
How This Book Is Organized
2
Syntax of the C# 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
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
4
Using Classes 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
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
6
UML Diagrams
Inheritance
Interfaces
Composition
Annotation
WithClass UML Diagrams
C# Project Files
7
Arrays, Files, and Exceptions in C#
Arrays
Collection Objects
ArrayLists
Hashtables
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
II
CREATIONAL PATTERNS
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
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
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
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
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
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
III
STRUCTURAL PATTERNS
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
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
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
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
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 from 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
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
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
IV
BEHAVIORAL PATTERNS
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
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
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
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
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
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
27
The Observer Pattern
Watching Colors Change
The Message to the Media
Consequences of the Observer Pattern
Program on the CD-ROM
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
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
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
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
0201844532T08292002
Brief Description:
A practical guide to writing C# programs using the most common patterns. This tutorial begins with introductions to C#, object-oriented programming and inheritance, and UML diagrams. It describes one of twenty-three design patterns, recommends when to use it, and explains the impact that it will have on the larger design.
|
