Source: Design Pattern in C#, 2002 by James W Cooper
"Design Patterns—Elements of Reusable Software, by Gamma,
Helm, Johnson, and Vlissides (1995). This book, commonly referred to as
the Gang of Four, or “GoF,” book, has had a powerful impact on those
seeking to understand how to use design patterns and has become an all time bestseller."
"Design patterns are just convenient ways of reusing object oriented
code between projects and between programmers."
"Model-View-Controller framework for Smalltalk (Krasner and Pope 1988), which divided the user interface problem into three parts, as shown in Figure 1-1. The parts were referred to as a data model, which contains the computational parts of the program; the view, which presented the user interface; and the controller, which interacted between the user and the view."
"In other words, design patterns describe how objects communicate without
become entangled in each other’s data models and methods."
"Design patterns focus more on reuse of recurring architectural design
themes, while frameworks focus on detailed design and
implementation.” (Coplien and Schmidt 1995)"
·
Creational patterns create objects for you rather than having you
instantiate objects directly. This gives your program more flexibility in
deciding which objects need to be created for a given case.
·
Structural patterns help you compose groups of objects into larger
structures, such as complex user interfaces or accounting data.
·
Behavioral patterns help you define the communication between
objects in your system and how the flow is controlled in a complex
program.
"Program to an interface and not to an implementation.
Putting this more succinctly, you should define the top of any class
hierarchy with an abstract class or an interface, which implements no
methods but simply defines the methods that class will support. Then in all
of your derived classes you have more freedom to implement these
methods as most suits your purposes."
"
Object composition. This is simply the construction of objects that contain others:
encapsulation of several objects inside another one."
*For example, the Listbox, DataGrid, and TreeView are introduced in the Adapter and Bridge patterns.
*We show how to paint graphics objects in the Abstract Factory,
*We introduce the Enumeration interface in the Iterator and in the Composite, where we also take up formatting.
*We use exceptions in the Singleton pattern and,
*discuss ADO.NET database connections in the Façade pattern.
*And we show how to use C# timers in the Proxy pattern.
--------------------------
Managed languages are
garbage collected.
Garbage collected languages take care of releasing unused
memory: you never have to be concerned with this. As soon as the garbage
collection system detects that there are no more active references to a
variable, array or object, the memory is released back to the system. So
you no longer need to worry as much about running out of memory
because you allocated memory and never released it. Of course, it is still
possible to write memory-eating code, but for the most part you do not
have to worry about memory allocation and release problems.
--------------------------
The most significant problem is that the user
interface and the
data handling are combined in a single program module, rather than being handled separately. It is usually a good idea to keep the data manipulation and the interface manipulation separate so that changing interface logic doesn’t impact the computation logic and vice-versa.
"We will begin class names with capital letters and instances of classes with lowercase letters. We will also spell instances and classes with a mixture of lowercase and capital letters to make their purpose clearer: swimmerTime"
"In C# as well as other object oriented languages, you can have several
class methods with the same name as long as they have different calling
arguments or
signatures."
Replacing Methods Using NewAnother way to replace a method in a base class when you cannot declare
the base class method as virtual is to use the new keyword in declaring the
method in the derived class. If you do this, it effectively hides any
methods of that name (regardless of signature) in the base class. In that
case, you cannot make calls to the base method of that name from the
derived class, and must put all the code in the replacement method.
public new void draw(Graphics g) {
g.DrawRectangle (rpen, x, y, w, h);
g.DrawRectangle (rdPen, x +5, y+5, w, h);
UML
The symbols in front of the names indicate that member’s visibility,
where “+” means public,
“- ” means private, and
“#” means protected.
Static methods are shown underlined.
Abstract methods may be shown in italics or with an “{abstract}” label.
HashtablesA Hashtable is a variable length array where every entry can be referred to
by a key value.
Typically, keys are strings of some sort, but they can be any sort of object. Each element must have a unique key, although the elements themselves need not be unique. Hashtables are used to allow rapid access to one of a large and unsorted set of entries, and can also be used by reversing the key and the entry values to create a list where each entry is guaranteed to be unique.
Hashtable hash = new Hashtable ();
float freddy = 12.3f;
hash.Add ("fred", freddy); //add to table
//get this one back out
float temp = (float)hash["fred"];
File HandlingThe file handling objects in C# provide you with some fairly flexible
methods of handling files.
The File Object
The File object represents a file, and has useful methods for testing for a
file’s existence as well as renaming and deleting a file. All of its methods
are static, which means that you do not ( and cannot) create an instance of
File using the new operator. Instead, you use its methods directly.
if (File.Exists ("Foo.txt"))
File.Delete ("foo.txt");
You can also use the File object to obtain a FileStream for reading and
writing file data:
//open text file for reading
StreamReader ts = File.OpenText ("foo1.txt");
//open any type of file for reading
FileStream fs = File.OpenRead ("foo2.any");
Some of the more useful File methods are shown in the table below:
Static method Meaning
File.FileExists(filename) true if file exists
File.Delete(filename) Delete the file
File.AppendText(String) Append text
File.Copy(fromFile, toFile) Copy a file
File.Move(fromTile, toFile) Move a file, deleting old
copy
File.GetExtension(filename) Return file extension
File.HasExtension(filename) true if file has an
extension.
Reading Text File
To read a text file, use the File object to obtain a StreamReader object.
Then use the text stream’s read methods:
StreamReader ts = File.OpenText ("foo1.txt");
String s =ts.ReadLine ();
Writing a Text File
To create and write a text file, use the CreateText method to get a
StreamWriter object.
//open for writing
StreamWriter sw = File.CreateText ("foo3.txt");
sw.WriteLine ("Hello file");
If you want to append to an existing file, you can create a StreamWriter
object directly with the Boolean argument for append set to true:
//append to text file
StreamWriter asw = new StreamWriter ("foo1.txt", true);
Exceptions in File Handling
A large number of the most commonly occurring exceptions occur in
handling file input and output. You can get exceptions for illegal
filenames, files that do not exist, directories that do not exist, illegal
filename arguments and file protection errors. Thus, the best way to
handle file input and output is to enclose file manipulation code in Try
blocks to assure yourself that all possible error conditions are caught, and
thus prevent embarrassing fatal errors. All of the methods of the various
file classes show in their documentation which methods they throw. You
can assure yourself that you catch all of them by just catching the general
Exception object, but if you need to take different actions for different
exceptions, you can test for them separately.
For example, you might open text files in the following manner:
try {
//open text file for reading
StreamReader ts = File.OpenText ("foo1.txt");
String s =ts.ReadLine ();
}
catch(Exception e ) {
Console.WriteLine (e.Message );
}
