Table of 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. 0201844532T08292002Promotional Information
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.
Promotional Information
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.
About the Author
James W. Cooper is a research staff member in the
Advanced Information Retrieval and Analysis Department at the IBM
Thomas J. Watson Research Center. He is also a columnist for Java
Pro magazine and a reviewer for Visual Basic Programmer's Journal.
He has published 14 books, which include Principles of
Object-Oriented Programming Using Java 1.1 (Ventana) and The Visual
Basic Programmer's Guide to Java (Ventana).
0201844532AB05132002