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

68.else {

69.throw new InvalidOperationException(

70."Collection has changed during enumeration.");

71.}

72.return true;

}

73.Add this code for the Current property:

74.‘ Visual Basic

75.Public ReadOnly Property Current() As Object _

76.Implements System.Collections.IEnumerator.Current

77.Get

78.If (m_initialCount <> m_points.Count) Then

79.Throw New InvalidOperationException( _

80."Collection has changed during enumeration.")

81.ElseIf (m_position >= m_points.Count) Then

82.Throw New InvalidOperationException( _

83."Enumeration value is invalid.")

84.Else

85.Return m_points(m_position)

86.End If

87.End Get

88.End Property

89.

90.// Visual C#

91.public object Current {

92.get {

93.if (m_initialCount != m_points.Count) {

94.throw new InvalidOperationException(

95."Collection has changed during enumeration.");

96.}

97.else if (m_position >= m_points.Count) {

98.throw new InvalidOperationException(

99."Enumeration value is invalid.");

100.}

101.else {

102.return m_points[m_position];

103.}

104.}

}

Now that you’ve defined the enumerator for the class, you can implement the GetEnumerator method in the SortedPointList class.

Add the IEnumerable interface

1.If you’re using Visual Basic, click IEnumerable in the Class Name list. In

the Method Name list, click GetEnumerator. The declaration for the GetEnumerator method is added to the class.

If you’re using Visual C#, in the Class View, expand the SortedPointList class and Bases And Interfaces. Right-click the IEnumerable interface in the Class View, point to Add, and then click Implement Interface on the shortcut menu.

The declaration for the GetEnumerator method is added to the class.

2.Add this code for the GetEnumerator method:

3.‘ Visual Basic

4.Public Function GetEnumerator() As System.Collections.IEnumer ator _

5.Implements System.Collections.IEnumerable.GetEnumerator

6.Return New PointEnumerator(m_points)

7.End Function

8.

9.// Visual C#

10.#region Implementation of IEnumerable

11.public System.Collections.IEnumerator GetEnumerator() {

12.return new PointEnumerator(m_points);

13.}

#endregion

Test the interfaces

1.Modify the button click code in the Form1 class so that it uses the For Each or foreach control structure.

2.‘ Visual Basic

3.Private Sub Button1_Click(ByVal sender As System.Object, _

4.ByVal e As System.EventArgs) Handles Button1.Click

5.Dim points As New SortedPointList()

6.points.AddRandomPoints(250, 200)

7.Dim graph As Graphics = Me.CreateGraphics

8.Dim count As Integer = 1

9.Dim aColor As Color

10.Dim pt As SortablePoint

11.

12.For Each pt In points

13.aColor = System.Drawing.Color.FromArgb(25, 25, count)

14.count += 1

15.Dim brush As New System.Drawing.SolidBrush(aColor)

16.graph.FillEllipse(brush, pt.X, pt.Y, 10, 10)

17.brush.Dispose()

18.Next

19.end sub

20.

21.// Visual C#

22.private void button1_Click(object sender, System.EventArgs e) {

23.SortedPointList points = new SortedPointList();

24.points.AddRandomPoints(250, 200);

25.Graphics graph = this.CreateGraphics();

26.

27.int count = 1;

28.foreach(SortablePoint pt in points) {

29.Color color = System.Drawing.Color.FromArgb(25,25,count+

+);

30.System.Drawing.SolidBrush brush =

31.new System.Drawing.SolidBrush(color);

The first overload overrides the ToString method found in the System.Object class. System.Object is the base class for every Visual Basic and Visual C# class. The second overload is a ToString method defined just for the class. It’s neither an override of a base implementation nor an implementation of an interface method. The last overload is the implementation of the IFormattable.ToString method, the only member of the IFormattable interface. This is the version of ToString that’s called if a formatting expression is evaluated. You could also implement an IFormatProvider class to provide additional formatting options for base types. In this example, if this code doesn’t recognize the format string, you pass the IFormatProvider interface along to another call to the ToString method.

Add the IFormattable interface

1.Add the IFormattable interface to the list of interfaces for the SortablePoint class:

2.‘ Visual Basic

3.Public Class SortablePoint

4.Implements IComparable, IFormattable

5.:

6.End Class

7.

8.// Visual C#

9.public class SortablePoint : IComparable, IFormattable {

10.:

}

11.Add this code to implement the IFormattable.ToString method. Because the System.Object class implements a parameterless ToString method, this ToString method is an overload. If the SortablePoint class doesn’t recognize the formatting string, the individual methods create a string by passing the formatProvider to the ToString methods of the individual fields.

12.‘ Visual Basic

13.Public Function ToString(ByVal format As String, _

14.ByVal formatProvider As System.IFormatProvider) As String _

15.Implements System.IFormattable.ToString

16.Dim result As String

17.Select Case format.ToUpper()

18.Case "L"

19.result = String.Format("({0}, {1})", m_x, m_y)

20.Case "S"

21.result = String.Format("{0},{1}", m_x, m_y)

22.Case Else

23.result = (m_x.ToString(format, formatProvider) & " " _

24.& m_y.ToString(format, formatProvider))

25.End Select

26.Return result

27.End Function

28.

29.// Visual C#

30.#region Implementation of IFormattable

31.public string ToString(string format, System.IFormatProvider

32.formatProvider) {

11.graph.FillEllipse(System.Drawing.Brushes.Black, pt.X, pt.Y, 10, 10)

12.Dim ptlocation As String = String.Format("{0:L}", pt)

13.graph.DrawString(ptlocation, New Font("Arial", 8), _

14.System.Drawing.Brushes.Black, pt.X + 11, pt.Y)

15.Next

16.End Sub

17.

18.// Visual C#

19.private void button1_Click(object sender, System.EventArgs e) {

20.SortedPointList points = new SortedPointList();

21.points.AddRandomPoints(5, 200);

22.Graphics graph = this.CreateGraphics();

23.

24.foreach (SortablePoint pt in points) {

25.graph.FillEllipse(System.Drawing.Brushes.Black, pt.X, pt.Y,

26.10, 10);

27.string ptlocation = String.Format("{0:L}", pt);

28.graph.DrawString(ptlocation, new Font("Arial", 8),

29.System.Drawing.Brushes.Black, pt.X + 11, pt.Y);

30.}

31.}

32.Press F5 to run the program. Here’s an example of the output:

Two Other Uses of Interfaces

In programming with the .NET Framework, you’ll implement interfaces primarily to provide services from your class. You might, in addition, use an interface for a project in the following two situations.

Multiple inheritance Classes created in Visual Basic and Visual C# can have only one base class, but they can implement multiple interfaces. Because interfaces behave polymorphically, like base classes, you can use interfaces to simulate multiple inheritance. Suppose you were creating a Backyard class and wanted it to derive from both Lawn and Garden, but Lawn and Garden didn’t share a common base class other than System.Object. You could choose to implement an ILawn interface and then implement the ILawn interface in a Lawn class. You then create Garden as a base class. When you create the Backyard class, it inherits from Garden and implements ILawn as you see here:

‘ Visual Basic

Public Class Backyard

Inherits Garden

Implements ILawn

End Class

// Visual C#

public class Backyard : Garden, ILawn {

}

It would appear that you haven’t gained much from this code because you have to reimplement all the members of ILawn. Fortunately, you can use containment and delegation to reuse some of your work. In the Backyard class, you can create a private instance of the Lawn class. This is containment. You then implement the ILawn methods by calling the corresponding method of the private Lawn instance. This is called delegation. You’re delegating the work of the ILawn interface to the contained Lawn member. Suppose the ILawn class has a Grow method and a Height property. Your code might look something like this:

‘ Visual Basic

Public Class Backyard

Inherits Garden

Implements ILawn

Private m_lawn As New Lawn()

Public Sub Grow() Implements ILawn.Grow

m_lawn.Grow()

End Sub

Public Property Height() As Integer Implements ILawn.Height

Get

Return m_lawn.Height

End Get

Set(ByVal Value As Integer)

m_lawn.Height = Value

End Set

End Property

End Class

// Visual C#

public class Backyard : Garden, ILawn {

private Lawn m_lawn = new Lawn();

#region Implementation of ILawn

public void Grow() {

m_lawn.Grow();

}

public int Height {

get { return m_lawn.Height; }

Chapter 10: Using Classes Interchangeably

Through Polymorphism

Overview

In this chapter, you’ll learn how to

§Use derived classes polymorphically.

§Override a base class event (Visual C#).

§Raise an event from the base class (Visual Basic).

§Create a class that derives from the UserControl class.

In the first several chapters, you used classes as abstractions of objects in the real world, creating classes to represent books, playing cards, and trains. In Chapter 8, you saw how to use inheritance of the Component class to make client code easier to write. In this chapter, you’ll see how to use object-oriented design, and polymorphism in particular, to solve a programming task. Polymorphism allows you to refer to an instance of a derived class through a base reference variable, but when you call a method or use a property, the method or property called is the one defined in the derived class. Thus, derived classes can respond in different ways to the same method call. In this chapter’s example, the class is designed to represent an object that solves both the real world problem and the programming problem. You’ll see how polymorphism simplifies the programming task and makes the design more easily extensible.

Pattern Maker

Your task in this chapter is to create an application that allows a user to create a set of patterns. The user can draw the patterns by using straight lines or by importing a bitmap file created in another application, such as Paint. The following graphic shows the user interface.

The user selects a pattern by clicking one of the patterns in the Templates panel. When clicked, the pattern is displayed in an editor that allows the user to modify the pattern. The particular type of editor depends on the template type. This application has two types of pattern templates. In the first type, the user modifies the pattern by drawing lines in a square. In the second type, the user selects an existing bitmap file that contains a drawing of a pattern. Both editor types contain a Save button. When the user clicks Save, the modified pattern is saved in the Patterns panel.

Pattern Maker Design

The Pattern Maker application presents two common programming tasks that can be accomplished by using polymorphism. The first challenge is to display the correct editor based on the pattern selected. The second is to create new instances of the patterns.

Designing the Pattern and Editor Classes

The Pattern Maker application supports two different pattern types: a drawn pattern and a bitmap pattern. If you can design the two pattern types to have the same base class, you can write one set of code to work with both types. Additionally, you can add more pattern types without rewriting your code. This polymorphic solution has the following advantages:

§You can easily add a new pattern type. You’ll write one block of code that deals only with base class references. At run time, you supply the derived class instances. To extend the application, you implement additional derived classes.

§The code is less repetitive. If you didn’t use polymorphism in this application, you’d have a block of code that created a new drawn pattern and displayed an editor for it. You’d have an almost identical block of code that did the same thing with the bitmap pattern. Polymorphism allows you to write and debug the code that creates and displays a pattern only once. The differences in how the patterns are created and displayed are handled in the derived class code.