Explicit Interface Implementation — Resolving Conflicts and Hiding Members

Explicit interface implementation lets a class implement two interfaces that have members with identical names, without conflict. It is also used to hide implementation details — a member implemented explicitly is only accessible when the object is referenced through the interface type, not through the class type directly. This prevents callers from accidentally calling low-level implementation members when they have a class reference, while still satisfying the interface contract.

Resolving Name Conflicts with Explicit Implementation #

public interface IReader
{
    string Read();   // returns a string
}

public interface IWriter
{
    void Write(string value);
}

// No conflict here — different signatures. But what if both had:
public interface IJsonSerializer
{
    string Serialize(object obj);
}

public interface IXmlSerializer
{
    string Serialize(object obj);   // same name AND signature!
}

// ── Explicit implementation resolves the conflict ─────────────────────────
public class DataSerializer : IJsonSerializer, IXmlSerializer
{
    // Explicit implementation — InterfaceName.MemberName
    string IJsonSerializer.Serialize(object obj)
    {
        return System.Text.Json.JsonSerializer.Serialize(obj);
    }

    string IXmlSerializer.Serialize(object obj)
    {
        var serializer = new System.Xml.Serialization.XmlSerializer(obj.GetType());
        using var sw = new StringWriter();
        serializer.Serialize(sw, obj);
        return sw.ToString();
    }
}

// ── Accessing explicit members — MUST use interface reference ─────────────
var ds = new DataSerializer();
// ds.Serialize(obj);   // ← compile error! Serialize not accessible on DataSerializer

IJsonSerializer jsonSerializer = ds;
string json = jsonSerializer.Serialize(new { Name = "Alice" });  // ✓ JSON version

IXmlSerializer xmlSerializer = ds;
string xml = xmlSerializer.Serialize(new { Name = "Alice" });   // ✓ XML version

Hiding Implementation Details #

// IDisposable implemented explicitly — Dispose() hidden on the class reference
public class DatabaseConnection : IDisposable
{
    private bool _disposed = false;

    public void Open()  => Console.WriteLine("Connection opened");
    public void Query() => Console.WriteLine("Executing query...");
    public void Close() => Console.WriteLine("Connection closed");

    // Explicit — not visible when using DatabaseConnection directly
    void IDisposable.Dispose()
    {
        if (!_disposed)
        {
            Close();
            _disposed = true;
        }
    }
}

// Using statement uses IDisposable.Dispose() automatically
using (var conn = new DatabaseConnection())
{
    conn.Open();
    conn.Query();
}   // ← Dispose() called here via IDisposable interface, even though it's explicit

// conn.Dispose()   // ← would be compile error if only explicitly implemented

Common Mistakes #

Mistake 1 — Trying to access explicit member on class reference #

❌ Wrong — compile error:

var ds = new DataSerializer();
ds.Serialize(obj);   // compile error — must cast to interface first

✅ Correct — cast to the interface:

string json = ((IJsonSerializer)ds).Serialize(obj);
// or: IJsonSerializer js = ds; string json = js.Serialize(obj);

Mistake 2 — Adding access modifier to explicit implementation #

❌ Wrong — compile error:

public string IJsonSerializer.Serialize(object obj) { }  // compile error!

✅ Correct — no access modifier on explicit implementations.