C# Interface: What You Need to Know in Lesson 13

This lesson teaches C# Interfaces. Our objectives are as follows:

• Understand the Purpose of Interfaces.
• Define an Interface.
• Use an Interface.
• Implement Interface Inheritance.

An interface looks like a class but has no implementation. The only thing it contains is declarations of events, indexers, methods and/or properties. The reason interfaces only provide declarations is because they are inherited by classes and structs. Those must provide an implementation for each interface member declared. Let’s explore C# Interface further.

What are interfaces good for if they don’t implement functionality? They’re great for putting together plug-n-play like architectures where components can be interchanged at will. Since all interchangeable components implement the same interface, they can be used without any extra programming. The interface forces each component to expose specific public members that will be used in a certain way.

Since interfaces must be implemented by derived classes and structs, they define a contract. If class foo implements the IDisposable interface, it is making a statement that it guarantees it has the Dispose() method. That is the only member of the IDisposableinterface. Any code that wishes to use class foo may check to see if class foo implements IDisposable. When the answer is true, then the code knows that it can call foo.Dispose(). Listing 13-1 shows how to define an interface:

Listing 13-1. Defining an Interface: MyInterface.cs

interface IMyInterface
{
    void MethodToImplement();
}

Listing 13-1 defines an interface named IMyInterface. A common naming convention is to prefix all interface names with a capital “I”. This interface has a single method named MethodToImplement(). It could have been any type of method declaration with different parameters and return types. I just chose to declare this method with no parameters and a void return type to make the example easy. Notice that this method does not have an implementation (instructions between curly braces – {}), but instead ends with a semi-colon, “;“. This is because the interface only specifies the signature of methods that an inheriting class or struct must implement. Listing 13-2 shows how this interface could be used.

Listing 13-2. Using an Interface: InterfaceImplementer.cs

class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
    }

    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }
}

The InterfaceImplementer class in Listing 13.2 implements the IMyInterface interface. Indicating that a class inherits an interface is the same as inheriting a class. In this case, the following syntax is used:

class InterfaceImplementer : IMyInterface

Now that this class inherits the IMyInterface interface, it must implement its members. It does this by implementing theMethodToImplement() method. Notice that this method implementation has the exact same signature, parameters and method name, as defined in the IMyInterface interface. Any difference between the method signature in the interface and the method signature in the implementing class or struct will cause a compiler error. Additionally, a class or struct that inherits an interface must include all interface members. You will receive a compiler error if you don’t implement all interface members.

Interfaces may also inherit other interfaces. Listing 13-3 shows how inherited interfaces are implemented.

Listing 13-3. Interface Inheritance: InterfaceInheritance.cs

using System;

interface IParentInterface
{
    void ParentInterfaceMethod();
}

interface IMyInterface : IParentInterface
{
    void MethodToImplement();
}

class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
        iImp.ParentInterfaceMethod();
    }

    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }

    public void ParentInterfaceMethod()
    {
        Console.WriteLine("ParentInterfaceMethod() called.");
    }
}

The code in Listing 13.3 contains two interfaces: IMyInterface and the interface it inherits, IParentInterface. When one interface inherits another, any implementing class or struct must implement every interface member in the entire inheritance chain. Since the InterfaceImplementer class in Listing 13-3 inherits from IMyInterface, it also inherits IParentInterface. Therefore, the InterfaceImplementerclass must implement the MethodToImplement() method specified in the IMyInterface interface and the ParentInterfaceMethod() method specified in the IParentInterface interface.

Final Thoughts About C# Interface

• Interfaces stipulate what a class needs to do, not how.
• It can’t have private members.
• The members are abstract and public by default.
• It can’t contain fields since it represents a specific implementation of data.
• Interfaces make multiple inheritance possible, but it is not possible with classes.

Advantage of Interface

• Helps achieve loose coupling.
• Helps achieve total abstraction.
• Makes it possible to achieve component-based programming.
• Makes multiple inheritance and abstraction possible.
• Adds a plug and play the same way architecture does with applications.

You now understand what interfaces are and can implement an interface and use it in a class. Interfaces may also be inherited by other interface. Any class or struct that inherits an interface must also implement all members in the entire interface inheritance chain.

I invite you to return for Lesson 14: Introduction to Delegates and Events.