Explicit interface implementation C# with Example

Explicit interface implementation is necessary when you implement multiple interfaces who define a common 
method, but different implementations are required depending on which interface is being used to call the method 
(note that you don't need explicit implementations if multiple interfaces share the same method and a common 
implementation is possible). 
interface IChauffeur 
{ 
string Drive(); 
} 
interface IGolfPlayer 
{ 
string Drive(); 
} 
class GolfingChauffeur : IChauffeur, IGolfPlayer 
{ 
public string Drive() 
{ 
return "Vroom!"; 
} 
 

string IGolfPlayer.Drive() 
{ 
return "Took a swing..."; 
} 
} 
GolfingChauffeur obj = new GolfingChauffeur(); 
IChauffeur chauffeur = obj; 
IGolfPlayer golfer = obj; 
Console.WriteLine(obj.Drive()); // Vroom! 
Console.WriteLine(chauffeur.Drive()); // Vroom! 
Console.WriteLine(golfer.Drive()); // Took a swing... 
The implementation cannot be called from anywhere else except by using the interface: 
public class Golfer : IGolfPlayer 
{ 
string IGolfPlayer.Drive() 
{ 
return "Swinging hard..."; 
} 
public void Swing() 
{ 
Drive(); // Compiler error: No such method 
} 
} 
Due to this, it may be advantageous to put complex implementation code of an explicitly implemented interface in 
a separate, private method. 
An explicit interface implementation can of course only be used for methods that actually exist for that interface: 
public class ProGolfer : IGolfPlayer 
{ 
string IGolfPlayer.Swear() // Error 
{ 
return "The ball is in the pit"; 
} 
} 
Similarly, using an explicit interface implementation without declaring that interface on the class causes an error, 
too. 
Hint: 
Implementing interfaces explicitly can also be used to avoid dead code. When a method is no longer needed and 
gets removed from the interface, the compiler will complain about each still existing implementation. 
Note: 
Programmers expect the contract to be the same regardless of the context of the type and explicit implementation 
should not expose different behavior when called. So unlike the example above, IGolfPlayer.Drive and Drive 
should do the same thing when possible.