INTERFACES in C#

Painting ECC200 in C# INTERFACES

You can make the Sort method work with objects of type MyClass by making the class implement IComparable. To implement an interface, a class or struct must do two things: It must list the interface name in its base class list. It must provide an implementation for each of the interface s members. For example, the following code updates MyClass to implement interface IComparable. Notice the following about the code: The name of the interface is listed in the base class list of the class declaration. The class implements a method called CompareTo, whose parameter type and return type match those of the interface member. Method CompareTo is implemented following the definition given in the interface s documentation. That is, it returns a negative 1, positive 1, or 0, depending on its value compared to the object passed into the method. Interface name in base class list class MyClass : IComparable { public int TheValue; public int CompareTo(object obj) // Implementation of interface method { MyClass mc = (MyClass)obj; if (this.TheValue < mc.TheValue) return -1; if (this.TheValue > mc.TheValue) return 1; return 0; } } Figure 17-2 illustrates the updated class. The arrow from the grayed interface method to the class method indicates that the interface method does not contain code, but is implemented by the class-level method.

Now that MyClass implements IComparable, Sort will work on it as well. It would not, by the way, have been sufficient to just declare the CompareTo method it must be part of implementing the interface, which means placing the interface name in the base class list. The following shows the complete updated code, which can now use the Sort method to sort an array of MyClass objects. Main creates and initializes an array of MyClass objects and then prints them out. It then calls Sort and prints them out again to show that they have been sorted. class MyClass : IComparable // Class implements interface. { public int TheValue; public int CompareTo(object obj) // Implement the method. { MyClass mc = (MyClass)obj; if (this.TheValue < mc.TheValue) return -1; if (this.TheValue > mc.TheValue) return 1; return 0; } } class Program { static void PrintOut(string s, MyClass[] mc) { Console.Write(s); foreach (var m in mc) Console.Write("{0} ", m.TheValue); Console.WriteLine(""); } static void Main() { var myInt = new [] { 20, 4, 16, 9, 2 }; MyClass[] mcArr = new MyClass[5]; for (int i = 0; i < 5; i++) { mcArr[i] = new MyClass(); mcArr[i].TheValue = myInt[i]; } PrintOut("Initial Order: ", mcArr); Array.Sort(mcArr); PrintOut("Sorted Order: ", mcArr); } } // Create array of MyClass objs. // Initialize the array.

This code produces the following output: Initial Order: Sorted Order: 20 4 16 9 2 2 4 9 16 20

The previous section used an interface that was already declared in the BCL. In this section, we ll look at how to declare interfaces. The important things to know about declaring an interface are the following: An interface declaration cannot contain data members. An interface declaration can only contain declarations of the following kinds of nonstatic function members: Methods Properties Events Indexers The declarations of these function members cannot contain any implementation code. Instead, a semicolon must be used for the body of each member declaration. By convention, interface names begin with an uppercase I (e.g., ISaveable). Like classes and structs, interface declarations can also be split into partial interface declarations, as described in the Partial Classes section of 6.

For example, the following code shows the declaration of an interface with two method members: Keyword interface { int double } Interface name IMyInterface1

Semicolon in place of body DoStuff ( int nVar1, long lVar2 ); DoOtherStuff( string s, long x ); Semicolon in place of body

There is an important difference between the accessibility of an interface and the accessibility of interface members: An interface declaration can have any of the access modifiers public, protected, internal, or private. Members of an interface, however, are implicitly public, and no access modifiers, including public, are allowed. Access modifiers are allowed on interfaces. public interface IMyInterface2 { private int Method1( int nVar1, long lVar2 ); } Access modifiers are NOT allowed on interface members.