Interface in C# with Examples

What is Interface in C#

An interface in C# is a reference type that is similar to a class. It is a collection of similar methods(methods without a body), properties, events, and indexers. 'Methods without a body' is a method declared in an abstract class or an interface that doesn't have an implementation(body) in the class or interface where it's declared. Instead, the responsibility of providing the implementation lies with the derived (sub) classes.

Any class that inherits from the abstract class must provide an implementation for the abstract methods.

However, unlike classes, interfaces cannot have fields, constructors, or implementation of methods. They define a contract that any class implementing the interface must adhere to.

Example

An example to show what is an interface in c#:

Output:

Explanation:

• The IDrawable interface defines a method Draw.
• The Circle and Square classes both implement the IDrawable interface and provide their implementation of the Draw method.
• In the Main method, we create instances of both Circle and Square, treating them as IDrawable objects. This demonstrates polymorphism, where objects of different types are used interchangeably through a common interface.

Use of Interface in C#

1. Abstraction:

   Interfaces allow you to define a common set of methods that can be implemented by various classes, promoting code abstraction.

2. Multiple Inheritance:

   Unlike classes, C# supports multiple interface inheritance, allowing a class to implement multiple interfaces.

3. Polymorphism:

   Interfaces enable polymorphism by allowing different classes to be treated as instances of the same interface type.

Implementation of Interface in C#

Suppose we have an interface IShape with two methods, 'Draw' and 'CalculateArea':

Now, let's implement this interface in a class. We'll create a 'Circle' class that represents a circle and implements the 'IShape' interface:

In this example:

• The Circle class explicitly states that it implements the IShape interface.
• It provides concrete implementations for the Draw and CalculateArea methods defined in the IShape interface.
• The constructor initializes the radius field.

Now, you can create an instance of the Circle class and use it as an IShape:

This allows you to treat objects of the Circle class as instances of the IShape interface, enabling polymorphism and adherence to the contract defined by the interface.

Output:

Implementation of Multiple Interfaces in C#

In C#, a class can implement multiple interfaces, allowing it to inherit and provide implementations for members of all the interfaces.

In this example:

• The Circle class implements both the 'IDrawable' and 'ICalculable' interfaces.
• It provides concrete implementations for the Draw method from the 'IDrawable' interface and the Calculate method from the 'ICalculable' interface.

Now, you can create an instance of the Circle class and use it as both 'IDrawable' and 'ICalculable':

This demonstrates how a class can implement multiple interfaces, providing flexibility and allowing it to be used in different contexts based on the interfaces it implements.

Output:

Reference Variable of an Interface

In C#, you can use a reference variable of an interface type to refer to objects of classes that implement that interface. This allows for polymorphism and flexibility in your code. Here's an example:

Output:

In this example:

• The 'IShape' interface defines the 'Draw' method.
• The 'Circle' and 'Square' classes both implement the 'IShape' interface.
• Reference variables 'shape1' and 'shape2' are of the interface type 'IShape'.
• Even though the actual objects are of different types ('Circle' and 'Square'), you can call the Draw method on them using the interface reference variables.

Using interface reference variables allows you to write more flexible and extensible code, as you can work with different objects that adhere to the same interface contract. This is a key aspect of polymorphism in object-oriented programming.

C# Interface Practical Examples

Logger Interface

Output:

In this example, we define an interface called 'ILogger'. This interface has a single method 'Log' that takes a 'string' parameter, representing the message to be logged. The purpose of this interface is to establish a contract for logging functionality. We then provide an implementation of the 'ILogger' interface with the 'ConsoleLogger' class. It implements the 'Log' method by printing the log message to the console.

Advantages of Interface in C#

• Interfaces in C# allow you to define a contract without specifying the implementation details. This promotes abstraction, allowing developers to focus on what needs to be done without getting into how it should be done.
• C# supports multiple interface inheritance. A class can implement multiple interfaces, inheriting the contracts of each. This is especially valuable when a class needs to exhibit behaviors from multiple sources.
• Interfaces enable polymorphism, allowing objects of different classes that implement the same interface to be treated interchangeably. This enhances flexibility and promotes code reuse.
• Interfaces promote code reusability by allowing different classes to implement the same interface. This facilitates the reuse of code in various parts of an application or across different applications.
• Interfaces help in enforcing consistency across multiple classes. By defining a common set of methods or properties, interfaces ensure that implementing classes provide a consistent set of functionalities.

Limitations of C# Interfaces

• Interfaces only define method signatures, properties, events, and indexers, without providing any implementation. This means that each class implementing an interface must provide its implementation for the defined members.
• Interfaces cannot have fields, constants, or static members. They only define methods, properties, events, and indexers.
• All members of an interface are implicitly public. You cannot use access modifiers (such as public or private) within an interface to control member visibility.
• Interfaces cannot have constructors. They are not used to create instances; instead, they define a contract that implementing classes must adhere to.