C# | Explicit Interface Implementation - GeeksforGeeks

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.
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#
// C# Program to show the use of// Explicit interface implementationusing System; interface I1 {     void printMethod();} interface I2 {     void printMethod();} // class C implements two interfacesclass C : I1, I2 {     // Explicitly implements method of I1    void I1.printMethod()    {        Console.WriteLine("I1 printMethod");    }     // Explicitly implements method of I2    void I2.printMethod()    {        Console.WriteLine("I2 printMethod");    }} // Driver Classclass GFG {     // Main Method    static void Main(string[] args)    {        I1 i1 = new C();        I2 i2 = new C();         // call to method of I1        i1.printMethod();         // call to method of I2        i2.printMethod();    }}
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#
// C# Program to show the use of// Explicit interface implementationusing System; interface Pyramid {     // Method signature    void drawPyramid();} // Implements Pyramidclass Display : Pyramid {     // Using Explicit implementation    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();        }    }} // Driver Codeclass GFG {     // Main Method    static void Main(string[] args)    {        // Create object of the class using Interface        Pyramid obj = new Display();         // call method        obj.drawPyramid();    }}
         *
        ***
       *****
      *******
     *********
    ***********
   *************
  ***************
 *****************
*******************
 
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#
// C# Program to show the use of// Explicit interface implementationusing System; interface I1 {     // Property X    int X    {        set;        get;    }} interface I2 {     // Method X    int X();} class C : I1, I2 {     int x;     // Implicit implementation of    // the property    public int X    {        set { x = value; }        get { return x; }    }     // Explicit implementation of    // the method    int I2.X()    {        return 0;    }} // Driver Codeclass GFG {     // Main Method    static void Main(string[] args)    {        C c = new C();        I2 i2 = new C();         // Invokes set accessor        c.X = 10;         // Invokes get accessor        Console.WriteLine("Value of x set using X"+                             " from I1 is " + c.X);         // Call to the X method        Console.WriteLine("Value returned by I2.X()"+                                    " is " + i2.X());    }}
Value of x set using X from I1 is 10
Value returned by I2.X() is 0
 
erohsik
CSharp-Interfaces
C#
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Destructors in C#
Difference between Ref and Out keywords in C#
C# | Constructors
C# | String.IndexOf( ) Method | Set - 1
Introduction to .NET Framework
C# | Class and Object
C# | Abstract Classes
HashSet in C# with Examples
C# | Encapsulation
C# | Replace() Method