Csharp/CSharp Tutorial/Class/Explicit Interface Implementation

Explicit Interface Implementation

<source lang="csharp">using System; interface InterfaceOne {

   void Execute();

} interface InterfaceTwo {

   void Execute();

} class MyImplementation: InterfaceOne, InterfaceTwo {

   void InterfaceOne.Execute() 
   {
       Console.WriteLine("InterfaceOne.Execute implementation");
   }
   void InterfaceTwo.Execute()
   {
       Console.WriteLine("InterfaceTwo.Execute implementation");
   }

} class MainClass {

   public static void Main()
   {
       MyImplementation MyImplementation = new MyImplementation();
       
       InterfaceOne InterfaceOne = (InterfaceOne) MyImplementation;
       InterfaceOne.Execute();
       
       InterfaceTwo InterfaceTwo = (InterfaceTwo) MyImplementation;
       InterfaceTwo.Execute();
   }

}</source>

InterfaceOne.Execute implementation
InterfaceTwo.Execute implementation

Explicit interface implementation and its own implementation

<source lang="csharp">using System; interface InterfaceOne {

   void Execute();

} interface InterfaceTwo {

   void Execute();

} class MyImplementation: InterfaceOne, InterfaceTwo {

   void InterfaceOne.Execute() 
   {
       Console.WriteLine("InterfaceOne.Execute implementation");
   }
   void InterfaceTwo.Execute()
   {
       Console.WriteLine("InterfaceTwo.Execute implementation");
   }
   
   public void Execute()
   {
       ((InterfaceOne) this).Execute();
   }

} class MainClass {

   public static void Main()
   {
       MyImplementation MyImplementation = new MyImplementation();
       
       MyImplementation.Execute();
   }

}</source>

InterfaceOne.Execute implementation

Explicitly implement an interface member

<source lang="csharp">using System;

interface MyInterface {

 bool MyMethodA(int x); 
 bool MyMethodB(int x); 

}

class MyClass : MyInterface {

 // Explicit implementation. 
 bool MyInterface.MyMethodA(int x) { 
   if((x%2) != 0) 
      return true; 
   else 
      return false; 
 } 

 // Normal implementation. 
 public bool MyMethodB(int x) { 
   MyInterface o = this; // reference to invoking object 

   return !o.MyMethodA(x); 
 } 

}

class MainClass {

 public static void Main() { 
   MyClass ob = new MyClass(); 
   bool result; 

   result = ob.MyMethodB(4); 
   if(result) Console.WriteLine("4 is even."); 

   // result = ob.MyMethodA(4); // Error, MyMethodA not directly accessible 

   MyInterface iRef = (MyInterface) ob; 
   result = iRef.MyMethodA(3); 
   if(result) Console.WriteLine("3 is odd."); 

 } 

}</source>

4 is even.
3 is odd.

Interface member hiding

<source lang="csharp">using System;

public interface InterfaceA {

 void MethodA();

}

public interface InterfaceB : InterfaceA {

 new void MethodA();  // hides MethodA() in InterfaceA

} public class MyClass : InterfaceB {

 void InterfaceB.MethodA()
 {
   Console.WriteLine("InterfaceB implementation of MethodA()");
 }
 public void MethodA()
 {
   Console.WriteLine("InterfaceA implementation of MethodA()");
 }

}

class MainClass {

 public static void Main()
 {
   MyClass myClass = new MyClass();
   Console.WriteLine("Calling myClass.MethodA()");
   myClass.MethodA();
   InterfaceB mySteerable = myClass as InterfaceB;
   Console.WriteLine("Calling mySteerable.MethodA()");
   mySteerable.MethodA();
   InterfaceA myDrivable = myClass as InterfaceA;
   Console.WriteLine("Calling myDrivable.MethodA()");
   myDrivable.MethodA();
 }

}</source>

Calling myClass.MethodA()
InterfaceA implementation of MethodA()
Calling mySteerable.MethodA()
InterfaceB implementation of MethodA()
Calling myDrivable.MethodA()
InterfaceA implementation of MethodA()

Use explicit implementation to remove ambiguity

<source lang="csharp">using System;

interface MyInterfaceA {

 int Method(int x); 

}

interface MyInterfaceB {

 int Method(int x); 

}

// MyClass implements both interfaces. class MyClass : MyInterfaceA, MyInterfaceB {

 // explicitly implement the two Method()s 
 int MyInterfaceA.Method(int x) { 
   return x + x; 
 } 
 int MyInterfaceB.Method(int x) { 
   return x * x; 
 } 

 // call Method() through an interface reference. 
 public int MethodA(int x){ 
   MyInterfaceA a_ob; 
   a_ob = this; 
   return a_ob.Method(x); // calls MyInterfaceA 
 } 

 public int MethodB(int x){ 
   MyInterfaceB b_ob; 
   b_ob = this; 
   return b_ob.Method(x); // calls MyInterfaceB 
 } 

}

class MainClass {

 public static void Main() { 
   MyClass ob = new MyClass(); 

   Console.Write("Calling MyInterfaceA.Method(): "); 
   Console.WriteLine(ob.MethodA(3)); 

   Console.Write("Calling MyInterfaceB.Method(): "); 
   Console.WriteLine(ob.MethodB(3)); 
 } 

}</source>

Calling MyInterfaceA.Method(): 6
Calling MyInterfaceB.Method(): 9