C# ПІДРУЧНИКИ / c# / MS Press - Oop With MS Vb Net And C# Step By Step (2002)

§End Property

§

§‘ Not recommended. This declaration hides the

§‘ System.Drawing.Color class.

§‘ Private coverColor As Integer

§‘ Public ReadOnly Property Color() As Integer

§‘ Return coverColor

§‘ End Get

§‘ End Property

§End Class

§

§// Visual C#

§public class BookCover {

§private Color coverColor;

§public Color Color {

§get { return coverColor; }

§}

§

§// Not recommended. This declaration hides the

§// System.Drawing.Color class.

§// private int coverColor;

§// public int Color {

§// get { return coverColor; }

§// }

§}

§Preserve the value of a property if an attempt to set the property throws an exception. The class is responsible for maintaining a usable state and this leaves the instance in a consistent usable state.

§Provide a PropertyChanged event if it would be useful for the client of your class. Examples in the .NET Framework include

Control.TextChanged and Control.VisibleChanged.

§Allow the client code to set the properties in any order. If Dog.LastName must be set before Dog.FirstName, create a method for changing the properties that has parameters for LastName and FirstName. Within the method, set LastName first. This way, the developer doesn’t have to remember obscure property dependencies.

§Performing the get should not have an observable side effect. If retrieving the value has a side effect, using a method is preferable.

§Avoid using properties that return arrays. These properties are potentially inefficient, because of multiple accesses to the underlying field array and the likelihood that the array will be copied before returning it. Use a method to return the array instead of a property.

Event Guidelines

§Use Pascal Casing.

§Event names are typically verbs. Examples include Click, Load, and Paint.

§Event delegates have two parameters, sender of type System.Object and e of System.EventArgs or a class derived from System.EventArgs. An example from the .NET Framework is the MouseEventHandler delegate, shown below.

§‘ Visual Basic

§Public Delegate Sub MouseEventHandler(ByVal sender As Objec

t, _

§ByVal e As MouseEventArgs)

§

§// Visual C#

public delegate void MouseEventHandler(object sender, MouseEventArgs e);

§Events should be Subs in Visual Basic and void methods in C#.

§Use past and present verb forms for events that carry the concept of time relative to the event. In contrast to previous versions, do not use the Before and After prefixes for event naming. Examples include

Form.Closed and Form.Closing.

§The event delegate name ends in EventHandler. Examples include

MouseEventHandler and System.EventHandler.

§The name of the class that derives from System.EventArgs ends in EventArgs. This is the type of the second parameter to the event handler method. Examples include MouseEventArgs, DragEventArgs, and

ScrollEventArgs.

§Program defensively because control returns to the method that raised the event after the event handler is executed, and the client code might change the object in the event handler method. The following code highlights the location of code that would execute after the event handler call. Consider wrapping the event call in a Try or try structure.

§‘ Visual Basic

§Public Class DogBone

§Public Event Eaten As System.EventHandler

§Private weight As Integer

§

§Public Sub Eat(ByVal howMuch As Integer)

§weight -= howMuch

§If (weight <= 0) Then

§RaiseEvent Eaten(Me, New System.EventArgs())

§‘ State of the instance could be changed in the event

§‘ handler in the client code.

§End If

§End Sub

§End Class

§

§// Visual C#

§public class DogBone {

§public event System.EventHandler Eaten;

§private int weight;

§

§public void Eat(int howMuch) {

§weight -= howMuch;

§if (weight <= 0) {

§if (Eaten != null) {

§this.Eaten(this, new System.EventArgs());

§// State of the instance could be changed in the event

§// handler in the client code.

§}

§}

§}

}

Refactoring

Each chapter in this book has presented a problem statement, followed by a design and an implementation. That’s neat and tidy, but not necessarily how things work during development and maintenance. Often when you implement something more than a trivial application, you’ll look at it at the end and decide the code is messy. Perhaps you’ve had to add method parameters with obscure effects to handle special cases. Maybe your

Implementing the “Pull Up Field” Refactoring

In this exercise, you’ll move the Save button into the base class, PatternEditor.

Pull the Save button up into the PatternEditor class

1.Open the PatternMaker project from Chapter 10.

2.Double-click PatternEditor.vb or PatternEditor.cs in the Solution Explorer to open the control in the designer.

3.Set the Size property to 175, 150, to match the derived controls.

4.Drag a Button control onto the control. Set the Location to 88, 112, the Text property to Save, and the Name property to save.

The new base control, PatternEditor, is shown here:

Now that the Save button is in the base class, you don’t have a way to raise the Saved event even though you still need to have the derived class handle saving the pattern information back to the Pattern instance. Solve this problem by adding an overridable method, SavePattern, to the base class.

5.Double-click the Save button to create the Click event handler and call the SavePattern method. You’ll define the SavePattern method in the next step.

6.‘ Visual Basic

7.Private Sub save_Click(ByVal sender As System.Object, _

8.ByVal e As System.EventArgs) Handles save.Click

9.SavePattern()

10.RaiseEvent Saved(Me, New System.EventArgs())

11.End Sub

12.

13.// Visual C#

14.private void save_Click(object sender, System.EventArgs e) {

15.SavePattern();

16.if (Saved != null) {

17.Saved(this, new System.EventArgs());

18.}

}

19.Add the SavePattern method to the PatternEditor class.

20.‘ Visual Basic

21.Public Overridable Sub SavePattern()

22.End Sub

23.

24.// Visual C#

25.public virtual void SavePattern() {

}

The SavePattern method is overridden in the derived classes to save the pattern data.

26.If you’re using Visual Basic, delete the RaiseSaved event method in PatternEditor.vb. Don’t delete the Saved event. You still need to raise the event to the user interface.

Now that the Saved button is in the base class, you no longer need it in the derived classes.

Move the Save button out of the BitmapPatternEditor class

To finish the refactoring, you need to delete the Save buttons and override the

SavePattern method.

1.Right -click on BitmapPatternEditor.vb or BitmapPatternEditor.cs in the Solution Explorer and click View Code on the shortcut menu.

2.Add the SavePattern method to the BitmapPatternEditor class, and move the code from the save_Click method into the SavePattern method. If you’re using Visual Basic, you no longer need to call the RaiseSaved method. If you’re using Visual C#, you no longer need to raise the Saved event. The event is raised in the base class when the Save button is clicked.

3.‘ Visual Basic

4.Public Overrides Sub SavePattern()

5.m_pattern.BitmapFile = m_bitmapFile

6.End Sub

7.

8.// Visual C#

9.public override void SavePattern() {

10.m_pattern.BitmapFile = m_bitmapFile;

}

11.Delete the save_Click method in the BitmapPatternEditor class.

12.If you’re using Visual C#, delete the overridden Saved event.

13.// Visual C#

14.// Delete this override

public override event SavedEventHandler Saved;

15.Double-click BitmapPatternEditor.vb or BitmapPatternEditor.cs in the Solution Explorer to open the control in the designer.

16.Delete the Save button from the control.

17.Set the location of the Browse button to 8, 112. When the application is compiled in the next section, the control appears as shown below with the inherited button marked with a special icon.

Move the Save button out of the DrawnPatternEditor class

The changes are similar to those you made for the BitmapPatternEditor class. The steps are outlined here.

1.Right -click DrawnPatternEditor.vb or DrawnPatternEditor.cs in the Solution Explorer and click View Code on the shortcut menu.

2.Add the SavePattern method to the DrawnPatternEditor class, and move the code from the save_Click method into the SavePattern method. If you’re using Visual Basic, you no longer need to call the

RaiseSaved method.

3.‘ Visual Basic

4.Public Overrides Sub SavePattern()

5.m_pattern.Points = m_Points

6.End Sub

7.

8.// Visual C#

9.public override void SavePattern() {

10.m_pattern.Points = m_points;

}

11.Delete the save_Click method in the DrawnPatternEditor class.

12.Double-click DrawnPatternEditor.vb or DrawnPatternE ditor.cs in the Solution Explorer to open the control in the designer.

13.Delete the Save button from the control. Click Build Solution on the Build menu. The inherited Save button appears on the control.

20.Press F5 to run the application. You can create new bitmap patterns and drawn patterns. The functionality is identical to the first version you created, but the Save button doesn’t move around.

Refactoring a project might involve several changes such as the one you just saw. You’ll want to take a controlled approach to refactoring, unless you’re willing to take your application out of production and redo all your testing from scratch. With a more controlled approach, you can test your application, make a change, and then retest the application to ensure you haven’t introduced bugs into the system.

Design Patterns

A design pattern describes a common problem found in an object-oriented system and provides a solution to that problem. The classic text Design Patterns (Addison-Wesley, 1995), by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, catalogs 23 of the most common and important patterns.

A complete design pattern description includes the following elements:

§Pattern name Each pattern has a oneor two-word name that captures the abstraction of the pattern.

§Problem This describes the problem to be solved and defines when the pattern is applicable.

§Solution The solution describes the classes, their responsibilities, and the collaborations among them. The solution is described in an abstract way that can be applied in many contexts.

§Consequences Every design is a balance of advantages and disadvantages. For example, a solution might be fast, but consume a large amount of memory. Or the design might be optimized for a particular set of data, but unable to handle changes to the data structure.

While pattern descriptions often give concrete examples of known uses in software, the problem statement is unlikely to be an exact description of the problem you’re trying to solve. After reading and using some patterns, you’ll become familiar with the patterns and you’ll recognize how your problem falls into the same pattern.

Observer

The exercises in this book and the .NET Framework objects you’ve used have employed several patterns. By having some insight into the design, you’ll better understand how to use the object and make predictions about how well the objects are going to work in your applications. In Chapter 11, you implemented the Singleton pattern. Now take a look at another pattern, the Observer.

§Problem The Observer pattern is concerned with how objects in an application behave. If you were writing a kennel reservation system, you might have three forms in your application: one to take reservations, one to present a diagram showing empty and full kennels, and one to list the number of reservations each night. As reservations are made and canceled, the forms with kennels and reservation totals must change also. How do you keep the forms synchronized, making sure that the two other forms are notified each time there is a change in the reservations? Can you do this so that you can add more dependent forms without rewriting the reservation form?

§Solution The solution is to identify the subject and the observers in the system. In this example, the reservation form is the subject. The other forms are considered observers; they watch for changes in the subject. The subject class maintains a list of the observers through two methods it provides, Attach and Detach. For its part, the observer class provides an Update method that is called by the subject whenever the subject changes. When the subject changes, the Notify method calls the Update method for each observer in its list of observers. The subject also provides a GetState method that allows the observer to extract the information needed from the subject. The design is shown in the following UML diagram:

This pattern is also known as publish-subscribe. The subject publishes notifications when it changes. The observers subscribe to receive notifications.

Event-Handling and the Observer Pattern

The event-handling protocol of Visual Basic .NET and Visual C# displays the hallmarks of the Observer pattern. Consider the Button class as the subject. The Button publishes

a Click event. Observers, usually forms, subscribe to the Click event of the Button. The Attach method is implemented as AddHandler in Visual Basic and += in C#. The Detach method is implemented as RemoveHandler in Visual Basic and −= in C#. The Update method is implemented as a method in the form class, something like

Button1_Click(object sender, System.EventArgs e). When the Click event is raised, each method assigned through AddHandler or += is called. Information about the Button is found in the sender argument of the event handler. Note that we don’t actually know or care how event handling is implemented in the .NET Framework. Still, the Observer pattern provides an understanding of event handling that can make it easier to use and explain event-handling behavior.

Quick Reference

Appendix: Additional Resources

The following sources provide more information about object-oriented development.

Books

§Booch, Grady, Ivar Jacobson, and James Rumbaugh. The Unified Modeling Language User Guide. Boston: Addison-Wesley. 1998.

This book, by the original designers of the Unified Modeling Language, covers every detail of UML diagrams.

§Fowler, Martin. Refactoring: Improving the Design of Existing Code. Boston: Addison-Wesley. 1999.

This book provides practical, concrete techniques for improving existing code and for writing new code.

§Fowler, Martin with Kendall Scott. UML Distilled Second Edition: A Brief Guide to the Standard Object Modeling Language. Boston: Addison-Wesley. 1999.