How to implement an interface

To put a C# interface to use, you implement it with one or more classes or structures. The class and structure headings might look like this:

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

A C# interface specifies that classes or structures which implement the interface must provide specific implementations. For example, any class that implements the IRecordable interface must provide an implementation for the TakeANote method. The method that implements TakeANote doesn't use the override keyword. Using an interface isn’t like overriding a virtual method in classes. 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 provides 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 …

Visual Studio can help you implement an interface. Hover the cursor over the interface name in the class heading. A little underline appears underneath the first character of the interface name — it's a Smart Tag. Move the cursor until a menu opens and then choose Implement Interface. Presto! A skeleton framework appears; you fill in the details.

Using the newer C# 8.0 additions

Microsoft added a lot of functionality to C# 8.0 interfaces, so it pays to spend a little more time reviewing them. The IRecordable8 program provides more than the interface code snippets you’ve seen so far so that you can gain an understanding of the C# 8.0 difference. This code requires use of the .NET Core template, rather than the .NET Framework template. In addition, you must choose .NET 6.0 when asked for the Target Framework in the Console Application Wizard. Here is the IRecordable interface used for this example:

public interface IRecordable
{
// This is a default implementation.
public string GetName()
{
return "Writing Device";
}

private static int _numDevices;
public static int NumDevices
{
get { return _numDevices; }
set { if (value >= 0) _numDevices = value; }
}

public static bool IsDeviceAvailable()
{
if (NumDevices > 0)
return true;
else
return false;
}

string Description();

void PerformWrite(string Stuff);
}

This example doesn't show everything you can do, but it provides you with some ideas about what is possible. Notice that the instance method, GetName(), has an implementation, as does the static property, NumDevices, and the static method, IsDeviceAvailable(). You don't have to implement any of these members in your class if the default implementations will work. It’s essential that you create NumDevices as shown because interfaces don’t support the auto-implemented properties that classes do. However, you don’t see an implementation for either Description() or PerformWrite(), so you need to provide an implementation for them in your class. Consequently, this is what a class based on the IRecordable interface might look like:

internal class Pen : IRecordable
{
internal Pen()
{
IRecordable.NumDevices += 1;
}

~Pen()
{
IRecordable.NumDevices -= 1;
}

// Uncomment this method to obtain a specific
// implementation.
//public string GetName()
//{
// return "Pen";
//}

public string Description()
{
return "A device used for writing by hand.";
}

private bool PenWriting
{ get; set; }

public void PerformWrite(string Stuff)
{
if (PenWriting)
{
Console.WriteLine("Pen is writing.");
Console.WriteLine($"The paper contains: {Stuff}.");
}
else
Console.WriteLine("Pen isn't writing.");
}

public void StopWriting()
{
PenWriting = false;
Console.WriteLine("Pen off paper.");
}

public void StartWriting()
{
PenWriting = true;
Console.WriteLine("Pen on paper.");
}
}

The Pen class provides implementations for both Description() and PerformWrite(). In addition, it provides custom properties and methods to make these actions happen. The need to start and stop writing, for example, applies to a pen because your hand must move onto the paper and off the paper as needed. The example has GetName() commented out so that you can see the default implementation in action. If you uncomment this code, you can use the specific implementation for this class instead.

Notice that this example provides both a constructor and a finalizer that update the number of writing devices that are available. This value is part of the interface, so you call the interface to change it. Here is application code that is based on the Pen class.

static void Main(string[] args)
{
Console.WriteLine($"Pen available? {IRecordable.IsDeviceAvailable()}");
IRecordable myPen = new Pen();

Console.WriteLine($"Pen available? {IRecordable.IsDeviceAvailable()}");
((Pen)myPen).StartWriting();
myPen.PerformWrite("Hello There!");
Console.WriteLine($"Using a {myPen.GetName()}.");
((Pen)myPen).StopWriting();
myPen.PerformWrite("Goodbye");
Console.ReadLine();
}

It's possible to call static interface methods from within your code as well as any classes you create. You don’t have to instantiate an object to use them. So, the first check to IRecordable.IsDeviceAvailable() will provide a response of False because the code hasn't created a Pen object, myPen, yet.

If you want to use the interface features with myPen, you must create it as an IRecordable object. This means that you must tell the compiler that myPen is actually a Pen object every time you want to use one of the Pen-specific features, such as StartWriting(), or the compiler will complain. However, if you provide an override for an interface member in your class, the compiler will automatically use the override. Here's the default output from the example:

Pen available? False
Pen available? True
Pen on paper.
Pen is writing.
The paper contains: Hello There!.
Using a Writing Device.
Pen off paper.
Pen isn't writing.

How to name your interface

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

Why C# includes interfaces

The bottom line with interfaces is that an interface describes a capability, such as Swim Safety Training or Class A Driver’s License. A class implements the IRecordable interface when it contains a full version of the TakeANote method.

More than that, an interface is a contract. If you agree to implement every nondefault member defined in the interface, you get to claim its capability. Not only that, but a client using your class in an application knows calling those methods is possible. Implementing an interface is a promise, enforced by the compiler. (Enforcing promises through the compiler reduces errors.)

Mixing inheritance and interface implementation

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 defining IRecordable 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.

And he-e-e-re's the payoff

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 …

Pen pen = new Pen();
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 RecordShoppingList() 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.

Some programmers and many older online articles use the term interface in more than one way. You can see the C# keyword interface and how it’s used. People also talk about a class’s public interface, or the public methods and properties that it exposes to the outside world. Most sources now use the term Application Programming Interface or API to specify the methods, events, and properties used to access a class. This book uses API to refer to this public part of a class.

As a method return type

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

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

Somewhere, maybe in a constructor, you 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();
…
}

You can find more about the factory idea in the section “Hiding Behind an Interface,” later in this chapter. But note that the return type for CreateRecorder() is an interface type.

As the base type of an array or collection

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 Robot). 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.

As a more general type of object reference

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 in the next section.

Creating your own interface at home in your spare time

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 $"{padName}: {Grade:N0}";
}
}

Display() uses string interpolation (https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated) to format the information. It relies on a numeric string formatter for the Grade information (https://docs.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings).

The following DisplayArray() method in the Program class (place it before Main()) 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.

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

Implementing the incomparable IComparable<T> interface

C# defines the interface IComparable<T> this way (don't add this code to the SortInterface example):

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 the subject student's grade-point average is higher. 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 updated version of the Student class (with changes shown in bold):

// Student -- Description of a student with name and grade
class Student : IComparable<Student>, IDisplayable // Instantiation
{
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 $"{padName}: {Grade:N0}";
}

// 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;

// Generate a -1, 0 or 1 based on the Sort criteria (the student's
// grade). You could use class Double's CompareTo() method instead.
if (rightStudent.Grade < leftStudent.Grade)
{
Console.WriteLine($"{rightStudent.Name} < {leftStudent.Name}");
return -1;
}
if (rightStudent.Grade > leftStudent.Grade)
{
Console.WriteLine($"{rightStudent.Name} > {leftStudent.Name}");
return 1;
}

Console.WriteLine($"{rightStudent.Name} = {leftStudent.Name}");
return 0;
}
}

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

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

You provide the comparator (CompareTo()), and Array does all the work.

Creating a list of students

To test everything you've written so far, you need a list of students. The example provides a simple mechanism for doing so in a method called CreateStudentList() that relies on two fixed lists: names and grades. You place it at the end of the Student class. Here's the code you need:

// 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;
}

As you can see, CreateStudentList() defines an array of students that has the same length as the names list and relies on the Student class constructor. For each name and grade pair, the code creates another entry in students and then returns the completed array to the caller.

Testing everything using Main()

At this point, you have everything needed to sort a list of students. All you need is some code in Main() to demonstrate the functionality. The following code tests your Student class:

static void Main(string[] args)
{
// Sort students by grade…
Console.WriteLine("Using Array.Sort() to sort.");

// Get an unsorted array of students.
Student[] students = Student.CreateStudentList();

// Use the IComparable interface to sort the array.
Array.Sort(students);

// Now the IDisplayable interface to display the results.
DisplayArray(students);

// Use Language Integrated Query (LINQ) instead.
Console.WriteLine(" Using LINQ to sort.");
Student[] students2 = Student.CreateStudentList();
students2 = students2.OrderBy(C => C).ToArray();
DisplayArray(students2);

Console.Read();
}

Main() begins by creating a student list. It then sorts the students using Array.Sort(), which actually calls the CompareTo() method in Student. The code then calls DisplayArray() so that you can see the sorted output.

For comparison purposes, this example also uses Language Integrated Query (LINQ) to sort the values. To use LINQ, you must add the using System.Linq; statement to the beginning of your code file. Again, this method relies on CompareTo(), but the process is different. You can read more about LINQ at https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/linq/. For now, just know that it's a different type of sorting technique. Here’s what you see when you run this application:

Using Array.Sort() to sort.
Homer < Marge
Homer < Bart
Marge > Bart
Homer < Lisa
Bart < Lisa
Marge < Lisa
Homer < Maggie
Bart > Maggie
Lisa : 100
Marge : 85
Bart : 50
Maggie : 30
Homer : 0

Using LINQ to sort.
Homer < Bart
Maggie < Bart
Lisa > Bart
Marge > Bart
Bart = Bart
Bart = Bart
Lisa = Lisa
Marge < Lisa
Lisa = Lisa
Homer = Homer
Maggie > Homer
Lisa : 100
Marge : 85
Bart : 50
Maggie : 30
Homer : 0

The output statements show the action of Array.Sort() when combined with CompareTo() for this particular class. You also see that LINQ requires more steps to get the job done, but produces the same result as Array.Sort(). The goal is to sort the list as quickly as possible.

Making flexible dependencies through interfaces

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 API of dependencies, which you can do with interfaces.

Abstract or concrete: When to use an abstract class and when to use an interface

In Chapter 6 of this minibook, the discourse about birds says, “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. Also, 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.)

You can represent abstractions in two ways in C#: with abstract classes or with C# interfaces. The two have differences that can affect your choice of which one to use:

• Use an abstract class when you can profitably share an implementation with subclasses — the abstract base class can contribute real code that its subclasses can use by inheritance. For instance, maybe class Robot can handle part of the robot's tasks, just not movement.

  An abstract class doesn’t have to be completely abstract. Though it has to have at least one abstract, unimplemented method or property, some can provide implementations (bodies). Using an abstract class to provide an implementation for its subclasses to inherit prevents duplication of code. That’s always a good thing.

• Use an interface when you can’t share any implementation for the most part or your implementing class already has a base class.

  Most C# interfaces are purely, totally abstract. An older C# interface supplies no implementation of any of its methods (C# 8.0 and above allows a default implementation, which you can override or not, as needed). Yet it can also add flexibility that isn’t otherwise possible. The abstract class option may not be available because you want to add a capability to a class that already has a base class (that you can’t modify). For example, class Robot may already have a base class in a library that you didn’t write and therefore can’t alter. Interfaces are especially helpful for representing completely abstract capabilities, such as movability or displayability, that you want to add to multiple classes that may otherwise have nothing in common — for example, being in the same class hierarchy.

Doing HAS_A with interfaces

You discovered 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 (discussed in the “As a method return type” section, earlier in this chapter, and illustrated in the section “Hiding Behind an Interface”):

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