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.
If you want to learn more about Interface
check out the Object-Oriented Programming Course read more ⯈
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
orinternal
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
andBrake
). - The
Car
class implements theIVehicle
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}.");
}
}