C# | Implementación de interfaz explícita

Una interfaz es una colección de elementos vinculados libremente que tienen una funcionalidad o atributos comunes. Las interfaces contienen firmas de métodos, propiedades, eventos, etc. Las interfaces se utilizan para que una clase o estructura pueda implementar múltiples comportamientos. C# no admite el concepto de herencia múltiple debido a la ambigüedad que provoca. Pero muchos objetos de la vida real heredan propiedades de más de un tipo, por lo que se utilizan interfaces en lugar de extender clases. 

Una interfaz consiste solo en las firmas y no en su implementación, por lo tanto, cualquier clase o estructura que la implemente debe proporcionar la implementación anulando.

¿Qué es la implementación de interfaz explícita y cuándo se usa?

Decirle explícitamente al compilador que un miembro en particular pertenece a esa interfaz en particular se denomina implementación de interfaz explícita. 
Si una clase se implementa desde más de una interfaz que tiene métodos con la misma firma, la llamada a dicho método implementará el mismo método y no los métodos específicos de la interfaz. Esto anulará todo el propósito de usar diferentes interfaces. Ahí es cuando la implementación explícita entra en escena. Al usar una implementación explícita, puede decirle al compilador qué método de interfaz está sobrecargando y puede proporcionar diferentes funcionalidades para métodos de diferentes interfaces. Lo mismo ocurre con cualquier otro tipo de miembro como una propiedad, un evento.

Sintaxis:

class ClassName : InterfaceName
{
    returnType InterfaceName.method()
    { 
          // Your Code 
    }
}

Ejemplo 1: Este programa muestra el uso de una implementación de interfaz explícita. Aquí tenemos dos interfaces I1 e I2 que tienen la misma firma de método llamada printMethod con tipo de retorno como void. La clase C implementa estas dos interfaces, por lo que usamos una implementación de interfaz explícita para distinguir entre los métodos.

// C# Program to show the use of
// Explicit interface implementation
using System;
 
interface I1 {
 
    void printMethod();
}
 
interface I2 {
 
    void printMethod();
}
 
// class C implements two interfaces
class 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 Class
class 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

Ejemplo 2: aquí tenemos una pirámide de interfaz con un método dibujarPirámide . La clase Display hereda este método y proporciona una implementación que imprime una pirámide ‘ * ‘ en la pantalla. Usamos la implementación explícita para anular el método drawPyramid.

// C# Program to show the use of
// Explicit interface implementation
using System;
 
interface Pyramid {
 
    // Method signature
    void drawPyramid();
}
 
// Implements Pyramid
class 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 Code
class GFG {
 
    // Main Method
    static void Main(string[] args)
    {
        // Create object of the class using Interface
        Pyramid obj = new Display();
 
        // call method
        obj.drawPyramid();
    }
}

         *
        ***
       *****
      *******
     *********
    ***********
   *************
  ***************
 *****************
*******************

Ejemplo 3: podemos usar una implementación de interfaz explícita para propiedades pares y básicamente para cualquier otro miembro de la interfaz. Aquí tenemos la propiedad X y el método X en la interfaz I1 e I2 respectivamente con los mismos nombres y tipos de retorno. Solo usamos la implementación de interfaz explícita en el método X. De esta forma, el compilador usará la propiedad X a menos que se especifique lo contrario.

// C# Program to show the use of
// Explicit interface implementation
using 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 Code
class 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