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

In the next few sections, you’ll create a simple class that represents a point. You’ll use this class as a basis for implementing the IComparable, IEnumerable, IEnumerator, and IFormattable interfaces. These interfaces make your class more user friendly for other developers.

Implementing the IComparable Interface

The IComparable interface allows you to define an order for class instances. If your class represents an object that carries a meaningful interpretation of more or less, first or last, or larger or smaller, it’s reasonable to define the IComparable interface for your class. IComparable has one member, the CompareTo method. In this example, you implement a class that represents a point and compare points based on distance from the origin.

Create the SortablePoint class

1.Create a new Windows application project, and name it Points.

2.Add a new class to the project, and name the class SortablePoint.

3.Add the X and Y properties to the SortablePoint class:

4.‘ Visual Basic

46.// Visual C#

47.public SortablePoint() {

48.}

49.

50.public SortablePoint(int x, int y) {

51.m_x = x;

52.m_y = y;

}

Add the IComparable interface

1.Add the IComparable interface to the class declaration:

2.‘ Visual Basic

3.Public Class SortablePoint

4.Implements IComparable

5.‘ Code for the class is here.

6.:

7.End Class

8.

9.// Visual C#

10.public class SortablePoint : IComparable {

11.// Code for the class is here.

12.:

}

13.If you’re using Visual Basic, click IComparable in the Class Name list. In the Method Name list, click CompareTo. The declaration for the

CompareTo method is added to the class.

If you’re using Visual C#, in the Class View, expand the SortablePoint class and Bases And Interfaces. Right-click the IComparable interface in the Class View, point to Add, and then click Implement Interface. The declaration for the CompareTo method is added to the class.

‘ Visual Basic

Public Function CompareTo(ByVal obj As Object) As Integer _

Implements System.IComparable.CompareTo

End Function

// Visual C#

#region Implementation of IComparable

public int CompareTo(object obj) {

return 0;

}

#endregion

The CompareTo method compares the one class instance, Me or this, to another instance of the class, obj. If the two instances are equal, according to the class’s definition of sorting, CompareTo returns 0. If the Me or this instance is larger (comes second), CompareTo returns a positive integer. If the Me or this instance is smaller (comes first), CompareTo returns a negative integer.

14.Add code to the CompareTo function and create a helper function, SquaredDistance. Points are compared two at a time, so it doesn’t matter what value is returned by the CompareTo method, as long as a positive number is returned if the Me or this point is farther away than the other point. The SquaredDistance method returns the squared distance of the point from the origin. If the CompareTo method used

the actual distance to compare distances, the code would have to work with System.Double values. Working with System.Double values has three disadvantages. First, it negatively affects performance. Second, because of the way doubles are stored, it’s more work to test for equivalence. Third, the code has to convert the difference back into an integer, the return type of CompareTo.

15.‘ Visual Basic

16.Public Function CompareTo(ByVal obj As Object) As Integer _

17.Implements System.IComparable.CompareTo

18.Return Me.SquaredDistance() - _

19.CType(obj, SortablePoint).SquaredDistance()

20.End Function

21.

22.Private Function SquaredDistance() As Integer

23.Return (m_x * m_x) + (m_y * m_y)

24.End Function

25.

26.// Visual C#

27.#region Implementation of IComparable

28.public int CompareTo(object obj) {

29.return this.SquaredDistance() -

30.((SortablePoint)obj).SquaredDistance();

31.}

32.

33.private int SquaredDistance() {

34.return (m_x * m_x) + (m_y * m_y);

35.}

#endregion

Test the interface

The straightforward way to test the IComparable interface would be to create a list of points, sort them, and then print out the sorted points to check that they’re in order. Instead of doing that, this procedure generates a group of randomly placed points. You draw the points on the form and let the color density vary according to the sort order.

1.Open Form1 in the designer, and drag a Button control onto the form. Set the Text property to Draw.

2.Double-click the Draw button to create the Click event handler.

3.Add this code to generate points, sort them, and display them on the form. The ArrayList’s Sort method uses the IComparable.CompareTo method to sort the SortablePoint instances. The intensity of the color depends on the point’s position among the sorted points. The higher the value, the less intense the color.

4.‘ Visual Basic

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

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

7.Dim points As New ArrayList()

8.Dim rgen As New System.Random()

9.Dim pt As SortablePoint

49.Press F5 to run the program. Each time you click the Draw button, 250 more points are added to the form. Because the points aren’t drawn in the Paint event, the points won’t stay on the form if you minimize and then maximize it. To get a clear indication that the points are being sorted, comment out the call to Sort, and then run the program.

Implementing the IEnumerable and IEnumerator Interfaces

In the preceding example, you generated the points, added them to an ArrayList object, sorted them, and then drew them on the form. In this next example, you create a class, SortedPointList, that holds a group of points. Instead of using a for loop to access the members of the ArrayList class and then casting each item to the SortablePoint type, you’ll be able to use a For Each (or foreach in Visual C#) block that returns only a SortablePoint object.

The IEnumerable interface has one member, the GetEnumerator method. The GetEnumerator method returns an instance of a class that implements the IEnumerator interface. The IEnumerator interface has three members, the Reset and MoveNext methods and the Current property. The three members work together to enumerate the members of the SortedPointList class, points, as you see here:

‘ Visual Basic

Dim enumerator As IEnumerator = points.GetEnumerator()

dim pt As SortablePoint

While enumerator.MoveNext

pt = CType(enumerator.Current, SortablePoint)

‘ Use the SortablePoint instance here.

End While

// Visual C#

IEnumerator enumerator = points.GetEnumerator();

SortablePoint pt;

while (enumerator.MoveNext()) {

pt = (SortablePoint)enumerator.Current;

// Use the SortablePoint instance here.

}

Create the SortedPointList class

1.Add a new class to the project, and name it SortedPointList.

2.Modify the class to add the IEnumerable interface:

3.‘ Visual Basic

4.Public Class SortedPointList

5.Implements IEnumerable

6.End Class

7.

8.// Visual C#

9.public class SortedPointList : IEnumerable {

10.}

11.If you’re using Visual Basic, add the parameterless constructor:

12.‘ Visual Basic

13.Public Sub New()

End Sub

14.If you’re using Visual C#, add a using statement for the

System.Collections namespace:

15.// Visual C#

using System.Collections;

16.Add an instance of ArrayList and a method named AddRandomPoints, which adds a number of randomly generated points to the ArrayList class. This code is nearly identical to the Click event handler code for the Draw button in the previous section.

17.‘ Visual Basic

18.Private m_points As New ArrayList()

19.Public Sub AddRandomPoints(ByVal howMany As Integer, _

20.ByVal maximum As Integer)

21.m_points.Clear()

22.Dim rgen As New System.Random()

23.Dim count As Integer

24.For count = 0 To howMany - 1

25.m_points.Add( _

26.New SortablePoint(rgen.Next(maximum), rgen.Next(maxi

mum)))

27.Next

28.m_points.Sort()

29.End Sub

30.

31.// Visual C#

32.private ArrayList m_points = new ArrayList();

33.public void AddRandomPoints(int howMany, int maximum) {

34.m_points.Clear();

35.System.Random rgen = new System.Random();

36.for (int count = 0; count < howMany; count++) {

37.m_points.Add(new SortablePoint(rgen.Next(maximum),

38.rgen.Next(maximum)));

39.}

40.m_points.Sort();

}

Add the IEnumerator inner class

1.Declare a new class inside the PointList class, named PointEnumerator, that implements the IEnumerator interface.

2.‘ Visual Basic

3.Private Class PointEnumerator

4.Implements IEnumerator

5.End Class

6.

7.// Visual C#

8.private class PointEnumerator : IEnumerator {

}

The PointEnumerator class is called an inner class because it’s defined within another class. An instance of this class is created and returned by the GetEnumerator method. The user of the PointEnumerator instance needs to know only that the class implements the IEnumerator interface. So the only class that needs to know about the PointEnumerator class is the SortedPointList class.

9.If you’re using Visual Basic, click IEnumerator in the Class Name list. In the Method Name list, click Reset. The declaration for the Reset method is added to the class. Repeat this procedure for the MoveNext method and the Current property in the IEnumerator interface.

If you’re using Visual C#, in Class View, expand the SortedPointList class, the PointEnumerator class, and Bases And Interfaces. Right-click the IEnumerator interface, point to Add, and then click Implement Interface on the shortcut menu. The declarations for the IEnumerator methods are added to the class as you see here:

‘ Visual Basic

Private Class PointEnumerator

Implements IEnumerator

Public ReadOnly Property Current() As Object _

Implements System.Collections.IEnumerator.Current

Get

End Get

End Property

Public Function MoveNext() As Boolean _

Implements System.Collections.IEnumerator.MoveNext

End Function

Public Sub Reset() Implements System.Collections.IEnumerator.Reset

End Sub

End Class

// Visual C#

#region Implementation of IEnumerator

public void Reset() {

}

public bool MoveNext() { return true;

}

public object Current { get {

return null;

}

}

#endregion

10.Add these fields to the class PointEnumerator. The first member refers to the m_points collection of the SortedPointsList instance. The m_position is the current position in the enumeration. The m_initialCount is the count of points in m_points when the enumerator is instantiated. By convention in the .NET Framework, the enumerator’s MoveNext and Current members should fail if the collection being enumerated changes during enumeration. In this example, you’ll use the initial count of points to test whether the ArrayList class has changed.

11.‘ Visual Basic

12.Dim m_points As ArrayList

13.Dim m_position As Integer = -1

14.Dim m_initialCount As Integer

15.

16.// Visual C#

17.ArrayList m_points;

18.int m_position = -1; int m_initialCount;

19.Add the constructor to the class to initialize the points list:

20.‘ Visual Basic

21.Public Sub New(ByVal points As ArrayList)

22.m_points = points

23.m_initialCount = points.Count

24.End Sub

25.

26.// Visual C#

27.public PointEnumerator(ArrayList points) {

28.m_points = points;

29.m_initialCount = points.Count;

30.}

31.Add this code for the Reset method. You implement the enumerator by adding 1 to m_position with each call to MoveNext. The Current property returns the item in the ArrayList m_points at the m_position index. Because the first value in the enumeration is found by calling

the MoveNext method, the Reset method needs to hold the value of the index right before the first element in the ArrayList. The first element in ArrayList is at index 0, so the Reset method sets m_position to −1.

32.‘ Visual Basic

33.Public Sub Reset() Implements System.Collections.IEnumerator. Reset

34.m_position = -1

35.End Sub

36.

37.// Visual C#

38.public void Reset() {

39.m_position = -1;

}

40.Add the following code for the MoveNext method. The first test determines whether SortablePoint instances have been added or deleted from the m_points ArrayList. If not, m_position is incremented. Otherwise, the code throws an exception, InvalidOperationException.

41.‘ Visual Basic

42.Public Function MoveNext() As Boolean _

43.Implements System.Collections.IEnumerator.MoveNext

44.If (m_initialCount = m_points.Count) Then

45.m_position += 1

46.If (m_position >= m_points.Count) Then

47.Return False

48.Else

49.Return True

50.End If

51.Else

52.Throw New InvalidOperationException( _

53."Collection has changed during enumeration.")

54.End If

55.End Function

56.

57.// Visual C#

58.public bool MoveNext() {

59.if (m_initialCount == m_points.Count) {

60.m_position++;

61.if (m_position >= m_points.Count) {

62.return false;

63.}

64.else {

65.return true;

66.}

67.}