What are and how to use interfaces in C#

An interface in C# is a collection of method, property, event, or indexer definitions that a class or a structure can implement.

Unlike classes, interfaces do not contain method implementations; they only define the members that must be implemented by the classes or structures that implement them.

Interfaces are fundamental in object-oriented programming because they allow defining functionalities and behaviors that can be implemented by different classes, favoring maintainability and code reuse.

Interfaces in C#

The declaration of an interface is done using the interface keyword.

[modifier] interface InterfaceName
{
    // Method definition
    dataType MethodName(parameters);

    // Property definition
    dataType PropertyName { get; set; }
}

• InterfaceName: Is the unique name given to the interface.
• Modifier: Can be public or internal to define the access level of the interface.
• dataType: Specifies the data type of the properties and methods.
• MethodName, PropertyName: Are the unique identifiers of the methods, properties, and events respectively.
• parameters: Are the variables used to pass information to the method when called.

Implementation of Interfaces

To implement an interface in a class, the syntax of a colon (:) followed by the name of the interface is used. The class must provide implementations for all the members defined in the interface.

Here is an example of how to define and implement an interface in C#:

public interface IDriveable
{
    string LicensePlate { get; set; }

    // Methods
    void Drive();
    void Brake();
}

public class Car : IDriveable
{
    // Property implementation    
    public string LicensePlate { get; set; }

    // Method implementation
    public void Drive()
    {
        Console.WriteLine("The car is running.");
    }

    public void Brake()
    {
        Console.WriteLine("The car has stopped.");
    }
}

In this example:

• An interface IVehicle is defined with a property (LicensePlate) and two methods (Drive and Brake).
• The Car class implements the IVehicle interface and provides the implementation of all its properties and methods.

Polymorphism with interfaces

One of the most important features of interfaces is their ability to support polymorphism. This allows an instance of a class that implements an interface to be treated as an instance of that interface.

Suppose we have another class that implements IDriveable called Bike

public class Bike : IDriveable
{
	// implementation
}

Now we can define a variable of type IDriveable, and assign variables of type Car or Bike.

IDriveable vehicle;

vehicle = new Car();
vehicle.Start(); // Output: The car has started.
vehicle.Stop();  // Output: The car has stopped.

vehicle = new Bike();
vehicle.Start(); // Output: The bike has started moving.
vehicle.Stop();  // Output: The bike has stopped.

Implementing multiple interfaces

C# does not support direct multiple inheritance (a class derived from multiple base classes). However, a class can implement multiple interfaces, providing a way to achieve behavior similar to multiple inheritance.

For example, in this example, the Duck class implements the IFlyable and ISwimmable interfaces.

public interface IFlyable
{
    void Fly();
}

public interface ISwimmable
{
    void Swim();
}

public class Duck : IFlyable, ISwimmable
{
    public void Fly()
    {
        Console.WriteLine("The duck is flying.");
    }

    public void Swim()
    {
        Console.WriteLine("The duck is swimming.");
    }
}

Explicit implementation

C# allows explicit implementation of interface members. This is useful when a class implements multiple interfaces that may have methods with the same name, or when you want to provide specific implementations that are not directly accessible through the class.

In this example, the Multifunctional class implements the IPrintable and IScannable interfaces. But both interfaces declare a Print() method. We can explicitly declare the interfaces to resolve the name conflict.

public interface IPrintable
{
    void Print();
}

public interface IScannable
{
    void Print();
}

public class Multifunctional : IPrintable, IScannable
{
    void IPrintable.Print()
    {
        Console.WriteLine("Printing...");
    }

    void IScannable.Print()
    {
        Console.WriteLine("Scanning...");
    }
}

// Usage
IPrintable printer = new Multifunctional();
printer.Print(); // Output: Printing...

IScannable scanner = new Multifunctional();
scanner.Print(); // Output: Scanning...

Practical examples

Representation of an electronic device

This ISwitchable interface defines the methods that an electronic device should have. The Phone class implements this interface:

public interface ISwitchable
{
    // Methods
    void TurnOn();
    void TurnOff();
    void Restart();
}

public class Phone : ISwitchable
{
    // Method implementation
    public void TurnOn()
    {
        Console.WriteLine("The phone is turning on.");
    }

    public void TurnOff()
    {
        Console.WriteLine("The phone is turning off.");
    }

    public void Restart()
    {
        Console.WriteLine("The phone is restarting.");
    }
}

Communication behavior

This ICommunicator interface defines the methods that a communication device should have. The Phone class implements this interface while maintaining ISwitchable

public interface ICommunicator
{
    // Methods
    void Call(string number);
    void SendMessage(string number, string message);
}

public class Phone : ICommunicator, ISwitchable
{
	// ... code from the previous example for ISwitchable ... //
	
    // Implementation of ICommunicator methods
    public void Call(string number)
    {
        Console.WriteLine($"Calling number {number}.");
    }

    public void SendMessage(string number, string message)
    {
        Console.WriteLine($"Sending message to number {number}: {message}");
    }
}

Payment behavior

This IPayments interface defines the methods that a payment system should have. The ElectronicPayment class implements this interface:

public interface IPayments
{
    // Methods
    void ProcessPayment(decimal amount);
    void RefundPayment(decimal amount);
}

public class ElectronicPayment : IPayments
{
    // Method implementation
    public void ProcessPayment(decimal amount)
    {
        Console.WriteLine($"Processing payment of {amount}.");
    }

    public void RefundPayment(decimal amount)
    {
        Console.WriteLine($"Refunding payment of {amount}.");
    }
}