Explicit Interface Implementation in C# Explained

Explicit interface implementation in C# provides a mechanism to implement multiple interfaces that share conflicting method signatures within a single class or struct. This article examines why method collisions occur, how explicit implementation isolates distinct logic for identical method names, how consumers invoke these methods, and best practices for managing class APIs when working with overlapping interface contracts.

Understanding Method Name Collisions

In C#, a class can implement multiple interfaces. A collision occurs when two or more interfaces define a method with the same name, return type, and parameter list.

Consider the following interfaces:

public interface IEnglishSpeaker
{
    void Greet();
}

public interface ISpanishSpeaker
{
    void Greet();
}

If a class implements both interfaces implicitly:

public class Translator : IEnglishSpeaker, ISpanishSpeaker
{
    public void Greet()
    {
        Console.WriteLine("Hello!");
    }
}

In this scenario, a single Greet() method satisfies both IEnglishSpeaker and ISpanishSpeaker. While syntactically valid, this approach forces both interfaces to share the exact same behavior, making it impossible to produce different logic for each language contract.

The Role of Explicit Interface Implementation

Explicit interface implementation resolves this problem by binding the method implementation directly to a specific interface name. This allows a class to provide separate, unique logic for each colliding method signature.

public class Translator : IEnglishSpeaker, ISpanishSpeaker
{
    void IEnglishSpeaker.Greet()
    {
        Console.WriteLine("Hello!");
    }

    void ISpanishSpeaker.Greet()
    {
        Console.WriteLine("¡Hola!");
    }
}

By prefixing the method name with the interface name (e.g., IEnglishSpeaker.Greet()), the compiler distinguishes between the two contracts.

Syntax and Visibility Rules

Explicit interface implementations have distinct syntax characteristics:

1. No Access Modifiers: Explicit methods do not allow access modifiers such as public, private, or protected. The method's accessibility is dictated by the interface itself.
2. Class-Level Invisibility: Explicitly implemented methods are not part of the class's direct public API. Calling translator.Greet() on a concrete instance will result in a compiler error.

Invoking Explicitly Implemented Methods

To invoke an explicitly implemented method, the instance must be cast to the appropriate interface type:

Translator translator = new Translator();

// translator.Greet(); // Compile-time error

IEnglishSpeaker english = translator;
english.Greet(); // Outputs: Hello!

ISpanishSpeaker spanish = (ISpanishSpeaker)translator;
spanish.Greet(); // Outputs: ¡Hola!

This pattern ensures that consumers must reference the specific role or contract they intend to use, eliminating runtime ambiguity.

Key Advantages in Architecture

• Independent Logic: Decouples colliding methods so each interface can execute its own independent behavior.
• Cleaner Public API: Prevents specialized or internal interface methods from cluttering the public interface of a concrete class.
• Contract Enforcement: Forces calling code to interact with the class through specific abstractions, promoting loose coupling.