C# | Explicit Interface Implementation
Last Updated :
24 Sep, 2021
An Interface is a collection of loosely bound items that have a common functionality or attributes. Interfaces contain method signatures, properties, events etc. Interfaces are used so that one class or struct can implement multiple behaviors. C# doesn’t support the concept of Multiple Inheritance because of the ambiguity it causes. But a lot of real-life objects inherit properties of more than just one type, therefore interfaces are used instead of extending classes.
An Interface consists only of the signatures and not its implementation, therefore, any class or struct that implements it has to provide the implementation by overriding.
What is Explicit Interface Implementation and when is it used?
Explicitly telling the compiler that a particular member belongs to that particular interface is called Explicit interface implementation.
If a class implements from more than one interface that has methods with the same signature then the call to such a method will implement the same method and not the interface-specific methods. This will defeat the whole purpose of using different Interfaces. That is when Explicit implementation comes into the picture. Using explicit implementation you can tell the compiler which interface’s method you are Overloading and can provide different functionalities for methods of different interfaces. The same is the case for any other type of member like a property, event.
Syntax:
class ClassName : InterfaceName
{
returnType InterfaceName.method()
{
// Your Code
}
}
Example 1: This program shows the use of explicit interface implementation. Here we have two interfaces I1 and I2 that have the same method signature named printMethod with return type as void. Class C implements these two Interfaces, therefore we use explicit interface implementation to distinguish between the methods.
C#
using System;
interface I1 {
void printMethod();
}
interface I2 {
void printMethod();
}
class C : I1, I2 {
void I1.printMethod()
{
Console.WriteLine("I1 printMethod");
}
void I2.printMethod()
{
Console.WriteLine("I2 printMethod");
}
}
class GFG {
static void Main(string[] args)
{
I1 i1 = new C();
I2 i2 = new C();
i1.printMethod();
i2.printMethod();
}
}
|
Output:
I1 printMethod
I2 printMethod
Example 2: Here, we have an Interface Pyramid with a method drawPyramid. The class Display inherits this method and provides an implementation that prints a ‘*‘ pyramid on the screen. We use Explicit implementation to override drawPyramid method.
C#
using System;
interface Pyramid {
void drawPyramid();
}
class Display : Pyramid {
void Pyramid.drawPyramid()
{
for (int i = 1; i <= 10; i++)
{
for (int k = i; k < 10; k++)
Console.Write(" ");
for (int j = 1; j <= (2 * i - 1); j++)
Console.Write("*");
Console.WriteLine();
}
}
}
class GFG {
static void Main(string[] args)
{
Pyramid obj = new Display();
obj.drawPyramid();
}
}
|
Output:
*
***
*****
*******
*********
***********
*************
***************
*****************
*******************
Example 3: We can use explicit interface implementation for even properties and basically any other members of the interface. Here, we have property X and method X in interface I1 and I2 respectively with the same names and return types. We only use explicit interface implementation on method X. This way the compiler will use the property X unless specified otherwise.
C#
using System;
interface I1 {
int X
{
set;
get;
}
}
interface I2 {
int X();
}
class C : I1, I2 {
int x;
public int X
{
set { x = value; }
get { return x; }
}
int I2.X()
{
return 0;
}
}
class GFG {
static void Main(string[] args)
{
C c = new C();
I2 i2 = new C();
c.X = 10;
Console.WriteLine("Value of x set using X"+
" from I1 is " + c.X);
Console.WriteLine("Value returned by I2.X()"+
" is " + i2.X());
}
}
|
Output:
Value of x set using X from I1 is 10
Value returned by I2.X() is 0
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...