To put a C# interface to use, you implement it with one or more classes. The class heading looks like this:

class Pen : IRecordable  // Looks like inheritance, but isn't

Class Pen might look like this:

class Pen : IRecordable
{
  public void TakeANote(string note)    // Interface method implementations
  {                                     // MUST be declared public.
    // ... scribble a note with a pen ...
  }
}

This example fulfills two requirements: Note that the class implements IRecordable, and provide a method implementation for TakeANote().

The syntax indicating that a class inherits a base class, such as ThingsThatRecord, is essentially no different from the syntax indicating that the class implements a C# interface such as IRecordable:

public class PDA : ThingsThatRecord ...
public class PDA : IRecordable ...

The .NET naming convention for interfaces precedes the name with the letter I. Interface names are typically adjectives, such as IRecordable.

More than that, an interface is a contract. If you agree to implement every method defined in the interface, you get to claim its capability. Not only that, but a client using your class in her program is guaranteed to be able to call those methods. Implementing an interface is a promise — enforced by the compiler. (Enforcing promises through the compiler reduces errors.)

Unlike some languages, such as C++, C# doesn't allow multiple inheritance — a class inheriting from two or more base classes. Think of class HouseBoat inheriting from House and Boat. Just don't think of it in C#.

But although a class can inherit from only one base class, it can in addition implement as many interfaces as needed. After I treated recordability as an interface, a couple of the recording devices looked like this:

public class Pen : IRecordable          // Base class is Object.
{
  public void TakeANote(string note)
  {
    // Record the note with a pen.
  }
}
public class PDA : ElectronicDevice, IRecordable
{
  public void TakeANote(string note)
  {
    // Record the note with your thumbs or a stylus.
  }
}

Class PDA inherits from a base class and implements an interface.

To begin to see the usefulness of an interface such as IRecordable, consider this example:

public class Program
{
  static public void RecordShoppingList(IRecordable recorder)
  {
    // Jot it down, using whatever device was passed in.
    recorder.TakeANote(...);
  }
  public static void Main(string[] args)
  {
    PDA pda = new PDA();
    RecordShoppingList(pda);  // Oops, battery's low ...
    RecordShoppingList(pen);
  }
}

The IRecordable parameter is an instance of any class that implements the IRecordable interface. RecordShoppingList() makes no assumptions about the exact type of recording object. Whether the device is a PDA or a type of ElectronicDevice isn't important, as long as the device can record a note.

That concept is immensely powerful because it lets the RecordShopping List() method be highly general — and thus possibly reusable in other programs. The method is even more general than using a base class such as ElectronicDevice for the argument type, because the interface lets you pass almost arbitrary objects that don't necessarily have anything in common other than implementing the interface. They don't even have to come from the same class hierarchy, which truly simplifies the designing of hierarchies, for example.

I like to farm out to a factory method the task of creating the key objects I need. Suppose that I have a variable like this one:

IRecordable recorder = null;  // Yes, you can have interface-type variables.

Somewhere, maybe in my constructor, I call a factory method to deliver a particular kind of IRecordable object:

recorder = MyClass.CreateRecorder("Pen");  // A factory method is often static.

where CreateRecorder() is a method, often on the same class, that returns not a reference to a Pen but, rather, an IRecordable reference:

static IRecordable CreateRecorder(string recorderType)
{
  if(recorderType == "Pen") return new Pen();
  ...
}

I say more about the factory idea later in this chapter. But note that the return type for CreateRecorder() is an interface type.

Suppose that you have two classes, Animal and Robot, and that both are abstract. You want to set up an array to hold both thisCat (an Animal) and thatRobot (a cute droid). The only way is to fall back on type Object, the ultimate base class in C#, and the only base class that's common to both Animal and Robot as well as to their subclasses:

object[] things = new object[] { thisCat, thatRobot };

That's poor design for lots of reasons. But suppose that you're focused on the objects' movements. You can have each class implement an IMovable interface:

interface IMovable
{
  void Move(int direction, int speed, int distance);
}

and then set up an array of IMovables to manipulate your otherwise incompatible objects:

IMovable[] movables = { thisCat, thatRobot };

The interface gives you a commonality that you can exploit in collections.

The following variable declaration refers to a specific, physical, concrete object (see the later section "Abstract or concrete: When to use an abstract class and when to use an interface"):

Cat thisCat = new Cat();

One alternative is to use a C# interface for the reference:

IMovable thisMovableCat = (IMovable)new Cat();  // Note the required cast.

Now you can put any object into the variable that implements IMovable. This practice has wide, powerful uses in object-oriented programming, as you can see later in this chapter.

The following IDisplayable interface is satisfied by any class that contains a Display() method (and declares that it implements IDisplayable, of course). Display() returns a string representation of the object that can be displayed using WriteLine().

// IDisplayable -– Any object that implements the Display() method
interface IDisplayable
{
  // Return a description of yourself.
  string Display();
}

The following Student class implements IDisplayable:

class Student : IDisplayable
{
  public Student(string name, double grade)
  { Name = name; Grade = grade; }
  public string Name { get; private set; }
  public double Grade { get; private set; }
  public string Display()
  {
    string padName = Name.PadRight(9);
    return String.Format("{0}: {1:N0}", padName, Grade);
  }
}

Display() uses String's PadRight() and Format() methods, covered in Book I, Chapter 3, to return a neatly formatted string.

The following DisplayArray() method takes an array of any objects that implement the IDisplayable interface. Each of those objects is guaranteed (by the interface) to have its own Display() method (the entire program appears in the later section "Putting it all together"):

// DisplayArray -– Display an array of objects that implement
//   the IDisplayable interface.
public static void DisplayArray(IDisplayable[] displayables)
{
  foreach(IDisplayable disp in displayables)
  {
    Console.WriteLine("{0}, disp.Display());
  }
}

The following example shows the output from DisplayArray():

Homer    : 0
Marge    : 85
Bart     : 50
Lisa     : 100
Maggie   : 30

C# defines the interface IComparable<T> this way:

interface IComparable<T>
{
  // Compare the current T object to the object 'item'; return a
  // 1 if larger, −1 if smaller, and 0 if the same.
  int CompareTo(T item);
}

A class implements the IComparable<T> interface by implementing a CompareTo() method. Notice that CompareTo() takes an argument of type T, a type you supply when you instantiate the interface for a particular data type — as in this example:

class SoAndSo : IComparable<SoAndSo>  // Make me comparable.

When you implement IComparable<T> for your class, its CompareTo() method should return 0 if the two items (of your class type) being compared are "equal" in a way that you define. If not, it should return 1 or −1, depending on which object is "greater."

It seems a little Darwinian, but you could say that one Student object is "greater than" another Student object if his grade-point average is higher. (Okay, either a better student or a better apple-polisher — it doesn't matter.)

Implementing the CompareTo() method implies that the objects have a sorting order. If one student is "greater than" another, you must be able to sort the students from "least" to "greatest." In fact, most collection classes (including arrays but not dictionaries) supply a Sort() method something like this:

void Sort(IComparable<T>[] objects);

This method sorts a collection of objects that implement the IComparable <T> interface. It doesn't even matter which class the objects belong to. For example, they could even be Student objects. Collection classes such as arrays or List<T> could even sort this version of Student:

// Student -- Description of a student with name and grade
  class Student : IComparable<Student>, IDisplayable   // Instantiation
  {
    // Constructor -- initialize a new student object.
    public Student(double grade)
    { Grade = grade; }
    public double Grade { get; private set; }
    // Implement the IComparable<T> interface:
    // CompareTo -- Compare another object (in this case, Student objects) and
    //    decide which one comes after the other in the sorted array.
    public int CompareTo(Student rightStudent)
    {
      // Compare the current Student (call her 'left') against the other
      // student (call her 'right').
      Student leftStudent = this;

      // Now generate a −1, 0 or 1 based on the Sort criteria (the student's
      // grade). I could use class Double's CompareTo() method instead).
      if (rightStudent.Grade < leftStudent.Grade)
      {
        return −1;
      }

if (rightStudent.Grade > leftStudent.Grade)
      {
        return 1;
      }
      return 0;
    }
  }

Sorting an array of Students is reduced to this single call:

void MyMethod(Student[] students) // Where Student implements IComparable<T>
{
  Array.Sort(students); // Sort array of IComparable<Student>s
}

You provide the comparator (CompareTo()), and Array does all the work — sounds fair to me.

This is the moment you've been waiting for: the complete SortInterface program that uses the features described earlier in this chapter:

// SortInterface -- Demonstrates how the interface concept can be used
//    to provide an enhanced degree of flexibility in factoring
//    and implementing classes.
using System;
namespace SortInterface
{
  // IDisplayable -- An object that can convert itself into a displayable
  //    string format (duplicates what you can do by overriding
  //    ToString(), but helps me make a point)
  interface IDisplayable
  {
    // Display -- return a string representation of yourself.
    string Display();  }
  class Program
  {
    public static void Main(string[] args)
    {
      // Sort students by grade...
      Console.WriteLine("Sorting the list of students");
      // Get an unsorted array of students.
      Student[] students = Student.CreateStudentList();
      // Use the IComparable<T> interface to sort the array.
      Array.Sort(students);
      // Now the IDisplayable interface to display the results
      DisplayArray(students);

      // Now sort an array of birds by name using the same routines even
      // though the classes Bird and Student have no common base class.
      Console.WriteLine("
sorting the list of birds");
      Bird[] birds = Bird.CreateBirdList();
      // Notice that it's not necessary to cast the objects explicitly
      // to an array of IDisplayables (and wasn't for Students, either) ...

Array.Sort(birds);
      DisplayArray(birds);
      // Wait for user to acknowledge the results.
      Console.WriteLine("Press Enter to terminate...");
      Console.Read();
    }
    // DisplayArray -- Display an array of objects that
    //    implement the IDisplayable interface.
    public static void DisplayArray(IDisplayable[] displayables)
    {
      foreach(IDisplayable displayable in displayables)
      {
        Console.WriteLine("{0}", displayable.Display());
      }
    }
  }
  // ----------- Students -- Sort students by grade -------
  // Student -- Description of a student with name and grade
  class Student : IComparable<Student>, IDisplayable
  {
    // Constructor -- Initialize a new student object.
    public Student(string name, double grade)
    { Name = Name; Grade = grade; }
    // CreateStudentList -- To save space here, just create
    // a fixed list of students.
    static string[] names = {"Homer", "Marge", "Bart", "Lisa", "Maggie"};
    static double[] grades = {0, 85, 50, 100, 30};
    public static Student[] CreateStudentList()
    {
      Student[] students = new Student[names.Length];
      for (int i = 0; i < names.Length; i++)
      {
        students[i] = new Student(names[i], grades[i]);
      }
      return students;
    }
    // Access read-only properties.
    public string Name { get; private set; }
    public double Grade { get; private set; }
    // Implement the IComparable interface:
    // CompareTo -- Compare another object (in this case, Student objects)
    //    and decide which one comes after the other in the sorted array.
    public int CompareTo(Student rightStudent)
    {
      // Compare the current Student (call her 'left') against
      // the other student (call her 'right').
      Student leftStudent = this;
      // Now generate a −1, 0 or 1 based on the Sort criteria (the student's
      // grade). Double's CompareTo() method would work, too.
      if (rightStudent.Grade < leftStudent.Grade)
      {
        return −1;
      }
      if (rightStudent.Grade > leftStudent.Grade)
      {
        return 1;
      }
      return 0;
    }
    // Display -- Implement the IDisplayable interface:

public string Display()
    {
      string padName = Name.PadRight(9);
      return String.Format("{0}: {1:N0}", padName, Grade);
    }
  }
  // -----------Birds -- Sort birds by their names--------
  // Bird -- Just an array of bird names.
  class Bird : IComparable<Bird>, IDisplayable
  {
    // Constructor -- initialize a new Bird object.
    public Bird(string name) { Name = name; }
    // CreateBirdList -- Return a list of birds to the caller;
    //    Use a canned list here to save space.
    static string[] birdNames =
       { "Oriole", "Hawk", "Robin", "Cardinal", "Bluejay", "Finch", "Sparrow"};
    public static Bird[] CreateBirdList()
    {
      Bird[] birds = new Bird[birdNames.Length];
      for(int i = 0; i < birds.Length; i++)
      {
        birds[i] = new Bird(birdNames[i]);
      }
      return birds;
    }
    public string Name { get; private set; }
    // Implement the IComparable interface:
    // CompareTo -- Compare the birds by name; use the
    //    built-in String class compare method.
    public int CompareTo(Bird rightBird)
    {
      // Compare the "current" bird to the "right hand object" bird.
      Bird leftBird = this;
      return String.Compare(leftBird.Name, rightBird.Name);
    }
    // Display -- Implement the IDisplayable interface.
    public string Display() { return Name; }
  }
}

The Student class (it's in the middle of the program listing) implements the IComparable<T> and IDisplayable interfaces, as described earlier. The CompareTo() method compares the students by grade, which results in the students being sorted by grade. Student's Display() method returns the name and grade of the student.

The other methods of Student include the read-only Name and Grade properties, a simple constructor, and a CreateStudentList() method. This method just returns a fixed list of students for the code to work on.

The Bird class at the bottom of the listing also implements the interfaces IComparable<T> and IDisplayable. The class implements CompareTo() by comparing the names of the birds using String.Compare(). So one bird is greater than another if its name is greater. Bird.CompareTo() alphabetizes the list. Bird's Display() method just returns the name of the bird.

If you've followed along with us so far, you're set up for the good part, back in Main(). The CreateStudentList() method is used to return an unsorted list, which is stored in the array students.

You might think it necessary to cast the array of students into an array of comparableObjects so that you can pass the students to Array's Sort() method:

IComparable<Student>[] comparables = (IComparable<Student>[])students;

But not so, my friend. Sort() sees that the array passed in consists of objects that implement IComparable<something> and simply calls CompareTo() on each Student object to sort them. Great, eh?

The sorted array of Student objects is then passed to the locally defined DisplayArray() method. DisplayArray() uses foreach to iterate through an array of objects that implement a Display() method (guaranteed by the objects' having implemented IDisplayable). In the loop, it calls Display() on each object and displays the result to the console using WriteLine().

The program in Main() continues by sorting and displaying birds! I think we can agree that birds have nothing to do with students. Yet the same Sort() and DisplayArray() methods work on Bird as on Student.

The output from the program appears:

Sorting the list of students
Lisa     : 100
Marge    : 85
Bart     : 50
Maggie   : 30
Homer    : 0

Sorting the list of birds
Bluejay
Cardinal
Finch
Hawk
Oriole
Robin
Sparrow
Press Enter to terminate...

There must be a way to implement Move() that doesn't require you to open a can of worms every time a client wants wriggling instead. You can use interfaces, of course!

Look at the following code that uses HAS_A, a now-familiar relationship between two classes in which one class contains the other:

public class Robot
{
  // This object is used to implement motion.
  protected Motor _motor = new Motor(); // Refers to Motor by name
  // ...
}
internal class Motor { ... }

The point about this example is that the contained object is of type Motor, where Motor is a concrete object. (That is, it represents a real item, not an abstraction.) HAS_A sets up a dependency between classes Robot and Motor: Robot depends on the concrete class Motor. A class with concrete dependencies is tightly coupled to them: When you need to replace Motor with something else, code that depends directly on Motor like this has to change too. Instead, insulate your code by relying only on the public interface of dependencies, which you can do with interfaces. You can depend on dependent objects in a, er, less dependent way.

In Chapter 7 of this minibook, in my little discourse about birds, I say, "Every bird out there is a subtype of Bird." In other words, a duck is an instance of a subclass Duck. You never see an instance of Bird itself — Bird is an abstraction. Instead, you always see concrete, physical ducks, sparrows, or hummingbirds. Abstractions are concepts. As living creatures, ducks are real, concrete objects. And, concrete objects are instances of concrete classes. (A concrete class is a class that you can instantiate. It lacks the abstract keyword, and it implements all methods.)

I mention earlier in this chapter that you can use interfaces as a more general reference type. The containing class can refer to the contained class not with a reference to a concrete class but, rather, with a reference to an abstraction — either an abstract class or a C# interface will work:

AbstractDependentClass dependency1 = ...;
ISomeInterface dependency2 = ...;

Suppose that you have an IPropulsion interface:

interface IPropulsion
{
  void Movement(int direction, int speed);
}

Class Robot can contain a data member of type IPropulsion instead of the concrete type Motor:

public class Robot
{
  private IPropulsion _propel;    //<--Notice the interface type here.
  // Somehow, you supply a concrete propulsion object at runtime ...
  // Other stuff and then:
  public void Move(int speed, int direction)
  {
    // Use whatever concrete propulsion device is installed in _propel.
    _propel.Movement(speed, direction); // Delegate to its methods.
  }
}

Robot's Move() method delegates the real work to the object referred to through the interface. Be sure to provide a way to install a concrete Motor or Engine or another implementer of IPropulsion in the data member. Programmers often install that concrete object — "inject the dependency" — by passing it to a constructor:

Robot r = new Robosnake(someConcreteMotor);  // Type IPropulsion

or by assigning it via a setter property:

r.PropulsionDevice = someConcreteMotor;      // Invokes the set clause

Another approach to dependency injection is to use a factory method (which I discuss earlier in this chapter, in the section "As a method return type," and illustrate in the section "Hiding Behind an Interface"):

IPropulsion _propel = CreatePropulsion();    // A factory method