Explicit interface implementation in C Sharp (C#) - Deep Dive

Overview - Explicit interface implementation

What is it?

Explicit interface implementation is a way in C# to make a class implement interface members so that they are only accessible through the interface, not directly from the class instance. This means the implemented methods or properties are hidden unless you use a reference of the interface type. It helps avoid name conflicts when multiple interfaces have members with the same name.

Why it matters

Without explicit interface implementation, if a class implements multiple interfaces with the same member names, it can cause confusion or errors because the class cannot distinguish which interface's member is being called. Explicit implementation solves this by hiding the interface members from the class's public API, making code clearer and safer. This is important in large projects or libraries where interfaces often overlap.

Where it fits

Before learning explicit interface implementation, you should understand basic interfaces and how to implement them in C#. After this, you can learn about interface inheritance, polymorphism, and advanced design patterns that rely on interface segregation and multiple interface implementations.

Mental Model

Core Idea

Explicit interface implementation hides interface members from the class’s public API, making them accessible only through the interface type.

Think of it like...

It's like having a secret drawer in a desk that only opens with a special key (the interface). You can't open it just by using the desk normally (the class instance).

Class Instance
  │
  ├─ Public members (normal methods/properties)
  └─ Hidden interface members (only via interface reference)

Interface Reference
  │
  └─ Access to explicit interface members

Usage:
  Class c = new Class();
  c.Method();          // Can't access explicit interface method

  Interface i = c;
  i.Method();          // Can access explicit interface method

Build-Up - 7 Steps

1

Foundation

Understanding interfaces in C#

Concept: Learn what interfaces are and how classes implement them.

An interface in C# is like a contract that says what methods or properties a class must have. For example: interface IWalk { void Walk(); } class Person : IWalk { public void Walk() { Console.WriteLine("Person is walking"); } } Here, Person promises to have a Walk method.

Result

Person objects can call Walk() because they implement IWalk.

Understanding interfaces is essential because explicit interface implementation builds on how classes fulfill interface contracts.

2

Foundation

Normal interface implementation basics

Concept: How to implement interface members normally and access them.

When a class implements an interface normally, the interface methods become part of the class's public methods: interface IRun { void Run(); } class Athlete : IRun { public void Run() { Console.WriteLine("Athlete runs fast"); } } Athlete a = new Athlete(); a.Run(); // Works directly This means the Run method is public and accessible from the class instance.

Result

You can call Run() directly on Athlete objects.

Normal implementation exposes interface members as public class members, which can cause conflicts if multiple interfaces have same member names.

3

Intermediate

Name conflicts with multiple interfaces

🤔Before reading on: If a class implements two interfaces with the same method name, do you think one method can serve both or do you need separate methods? Commit to your answer.

Concept: When two interfaces have the same member names, normal implementation causes conflicts.

Suppose: interface IFirst { void Show(); } interface ISecond { void Show(); } class Demo : IFirst, ISecond { public void Show() { Console.WriteLine("Show method"); } } Here, one Show method tries to serve both interfaces, but what if you want different behaviors?

Result

One Show method serves both interfaces, so you can't differentiate calls.

Name conflicts limit flexibility and clarity when implementing multiple interfaces with same member names.

4

Intermediate

Explicit interface implementation syntax

🤔Before reading on: Do you think explicit interface methods are accessible directly from the class instance or only through the interface? Commit to your answer.

Concept: Explicit interface implementation hides interface members from the class's public API using a special syntax.

You write the interface name before the member: class Demo : IFirst, ISecond { void IFirst.Show() { Console.WriteLine("IFirst Show"); } void ISecond.Show() { Console.WriteLine("ISecond Show"); } } Demo d = new Demo(); // d.Show(); // Error: Show not accessible IFirst f = d; f.Show(); // Calls IFirst.Show ISecond s = d; s.Show(); // Calls ISecond.Show

Result

Show methods are only accessible through interface references, not directly on Demo.

Explicit implementation solves name conflicts by hiding interface members from the class's public surface.

5

Advanced

When to use explicit interface implementation

🤔Before reading on: Do you think explicit implementation is only for name conflicts or can it also control API exposure? Commit to your answer.

Concept: Explicit implementation controls which members appear publicly and resolves conflicts, improving API design.

Use explicit implementation when: - Multiple interfaces have same member names - You want to hide interface members from class users - You want different behaviors for each interface Example: class Printer : IFirst, ISecond { public void Print() { Console.WriteLine("General print"); } void IFirst.Print() { Console.WriteLine("IFirst print"); } void ISecond.Print() { Console.WriteLine("ISecond print"); } } Printer p = new Printer(); p.Print(); // General print ((IFirst)p).Print(); // IFirst print ((ISecond)p).Print(); // ISecond print

Result

You get clear separation of interface behaviors and control over public API.

Knowing when to hide interface members improves code clarity and prevents accidental misuse.

6

Advanced

Limitations and accessibility of explicit members

Concept: Explicit interface members cannot have access modifiers and are always private to the class except via interface.

Explicit interface methods: - Cannot be public, private, or protected explicitly - Are implicitly private to the class - Are not visible on class instances Example: class Sample : IExample { void IExample.Method() { Console.WriteLine("Explicit method"); } } Sample s = new Sample(); // s.Method(); // Error IExample i = s; i.Method(); // Works This means explicit members are hidden unless accessed through interface.

Result

Explicit members are private to class and only accessible via interface references.

Understanding accessibility rules prevents confusion about why explicit members seem invisible on class instances.

7

Expert

Explicit implementation and interface inheritance

🤔Before reading on: If an interface inherits another interface, do you think explicit implementation must cover all inherited members or only the new ones? Commit to your answer.

Concept: Explicit implementation must cover all interface members including inherited ones, and can be used to implement multiple interface layers distinctly.

Consider: interface IBase { void BaseMethod(); } interface IDerived : IBase { void DerivedMethod(); } class Impl : IDerived { void IBase.BaseMethod() { Console.WriteLine("Base method"); } void IDerived.DerivedMethod() { Console.WriteLine("Derived method"); } } Impl obj = new Impl(); // obj.BaseMethod(); // Error IBase b = obj; b.BaseMethod(); // Works IDerived d = obj; d.DerivedMethod(); // Works This shows explicit implementation can separate interface layers clearly.

Result

All inherited interface members must be implemented explicitly or implicitly; explicit implementation can separate them cleanly.

Knowing explicit implementation works across interface inheritance helps design layered APIs and avoid accidental member exposure.

Under the Hood

At runtime, explicit interface implementations are compiled into methods that are not part of the class's public method table but are linked to the interface's method table. When you cast the class instance to the interface type, the runtime uses the interface's method table to call the correct explicit implementation. This hides the methods from normal class usage but allows interface-based polymorphism.

Why designed this way?

Explicit interface implementation was designed to solve the problem of method name conflicts and to allow classes to implement multiple interfaces with overlapping member names without exposing all interface members publicly. It also helps keep the class's public API clean and intentional, avoiding accidental calls to interface methods that are meant only for interface consumers.

┌───────────────┐
│   Class Obj   │
│ ┌───────────┐ │
│ │ Public    │ │
│ │ Methods   │ │
│ └───────────┘ │
│ ┌───────────┐ │
│ │ Explicit  │ │
│ │ Interface │ │
│ │ Methods   │ │
│ └───────────┘ │
└─────┬─────────┘
      │
      ▼
┌───────────────┐
│ Interface Ref │
│ Calls Explicit│
│ Methods Here  │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Can explicit interface methods be called directly on the class instance without casting? Commit to yes or no.

Common Belief: Explicit interface methods are just like normal methods and can be called directly on the class instance.

Reality: Explicit interface methods are hidden from the class's public API and can only be called through an interface reference.

Why it matters: Trying to call explicit methods directly causes compile errors and confusion about method availability.

Quick: If two interfaces have the same method name, can one normal implementation serve both without issues? Commit to yes or no.

Common Belief: One normal method implementation can serve multiple interfaces with the same method name without problems.

Reality: One normal method serves all interfaces with that name, so you cannot have different behaviors for each interface without explicit implementation.

Why it matters: This limits flexibility and can cause incorrect behavior when interfaces require distinct implementations.

Quick: Does explicit interface implementation change the accessibility of the method to public? Commit to yes or no.

Common Belief: Explicit interface methods are public because interfaces are public contracts.

Reality: Explicit interface methods are implicitly private to the class and only accessible via interface references, not public on the class itself.

Why it matters: Misunderstanding accessibility can lead to incorrect assumptions about method visibility and API design.

Quick: If an interface inherits another, do you only need to implement the new members explicitly? Commit to yes or no.

Common Belief: You only need to explicitly implement the new members of a derived interface, inherited members are automatic.

Reality: You must implement all members, including inherited ones, explicitly or implicitly; explicit implementation requires explicit methods for each member implemented explicitly.

Why it matters: Failing to implement inherited members causes compile errors and incomplete interface implementation.

Expert Zone

1

Explicit interface implementations do not participate in class inheritance; derived classes do not inherit explicit interface implementations from base classes.

2

Explicit interface implementation can be used to implement multiple interfaces with identical member signatures differently, enabling polymorphic behavior based on interface type.

3

Using explicit implementation can help maintain backward compatibility by hiding new interface members from existing class consumers.

When NOT to use

Avoid explicit interface implementation when you want interface members to be part of the class's public API for easier access. Instead, use normal implementation. Also, if interfaces do not have conflicting member names, explicit implementation adds unnecessary complexity.

Production Patterns

In large frameworks, explicit interface implementation is used to separate internal interface contracts from public APIs, allowing classes to implement multiple versions of an interface or to provide specialized behavior only when accessed through certain interfaces. It is common in UI frameworks, serialization libraries, and dependency injection containers.

Connections

Polymorphism

Explicit interface implementation is a form of polymorphism where the same class can behave differently depending on the interface reference used.

Understanding explicit implementation deepens grasp of polymorphism by showing how behavior can be hidden or exposed based on type.

Access Modifiers

Explicit interface implementation affects method accessibility, making interface members private to the class except via interface references.

Knowing how access modifiers work clarifies why explicit interface methods are hidden and how API surface is controlled.

Modular Design (Software Engineering)

Explicit interface implementation supports modular design by cleanly separating interface contracts from class implementation details.

This connection shows how language features enforce design principles that improve maintainability and reduce coupling.

Common Pitfalls

#1 Trying to call an explicit interface method directly on the class instance.

Wrong approach:

class MyClass : IExample {
void IExample.DoWork() {
Console.WriteLine("Working");
}
}

MyClass obj = new MyClass();
obj.DoWork(); // Error: DoWork not found

Correct approach:

IExample ie = new MyClass();
ie.DoWork(); // Works

Root cause:

Misunderstanding that explicit interface methods are hidden from the class's public API and require interface references.

#2 Implementing multiple interfaces with same method names normally, expecting different behaviors.

Wrong approach:

class Multi : IFirst, ISecond {
public void Show() {
Console.WriteLine("Show method");
}
}

IFirst f = new Multi();
ISecond s = new Multi();
f.Show(); // Same as s.Show()

Correct approach:

class Multi : IFirst, ISecond {
void IFirst.Show() {
Console.WriteLine("IFirst Show");
}
void ISecond.Show() {
Console.WriteLine("ISecond Show");
}
}

Root cause:

Not using explicit implementation to separate interface member behaviors.

#3 Assuming explicit interface methods can have access modifiers like public or private.

Wrong approach:

class Sample : IExample {
public void IExample.Method() { } // Error
}

Correct approach:

class Sample : IExample {
void IExample.Method() { }
}

Root cause:

Misunderstanding C# syntax rules for explicit interface implementation.

Key Takeaways

Explicit interface implementation hides interface members from the class's public API, making them accessible only through interface references.

It solves method name conflicts when a class implements multiple interfaces with identical member names by allowing separate implementations.

Explicit interface methods are implicitly private to the class and cannot be called directly on class instances.

This feature helps keep class APIs clean and intentional, improving code clarity and maintainability.

Understanding explicit interface implementation deepens knowledge of polymorphism, access control, and modular design in C#.