Default interface methods in C Sharp (C#) - Deep Dive

Overview - Default interface methods

What is it?

Default interface methods allow interfaces in C# to provide a default implementation for some of their methods. This means that when a class implements an interface, it does not have to implement every method if the interface already provides a default. This feature helps evolve interfaces without breaking existing code. It was introduced in C# 8.0 to improve flexibility in interface design.

Why it matters

Before default interface methods, adding a new method to an interface meant all classes implementing it had to change, which could break large codebases. Default interface methods solve this by letting interfaces add new methods with default behavior, so old classes keep working without changes. This makes software easier to maintain and evolve over time, especially in big projects or libraries.

Where it fits

Learners should know basic C# interfaces and how classes implement them. After this, understanding default interface methods helps with advanced interface design and versioning. Later topics include interface inheritance, explicit interface implementation, and design patterns using interfaces.

Mental Model

Core Idea

Default interface methods let interfaces provide built-in behavior so implementers can skip writing common code.

Think of it like...

It's like a recipe book that not only lists recipes but also includes a default way to prepare some dishes, so cooks can follow the book without needing extra instructions.

┌─────────────────────────────┐
│        Interface I          │
│ ┌───────────────────────┐ │
│ │ MethodA()             │ │
│ │ default MethodB()     │ │
│ └───────────────────────┘ │
└─────────────┬──────────────┘
              │
      ┌───────┴────────┐
      │ Implementing   │
      │ Class C        │
      │ ┌────────────┐ │
      │ │ MethodA()  │ │
      │ │ (override) │ │
      │ └────────────┘ │
      │ MethodB() uses │
      │ default impl  │
      └───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding basic interfaces

Concept: Interfaces define method signatures without implementations.

In C#, an interface is like a contract that says what methods a class must have, but not how they work. For example: interface IAnimal { void Speak(); } Any class that implements IAnimal must write its own Speak method.

Result

Classes must provide all methods declared in the interface.

Knowing that interfaces only declare methods sets the stage for why default implementations are a big change.

2

Foundation

Implementing interfaces in classes

Concept: Classes must implement all interface methods unless default implementations exist.

When a class says it implements an interface, it must write all the methods the interface declares. For example: class Dog : IAnimal { public void Speak() { Console.WriteLine("Woof!"); } } If Dog misses Speak, the code won't compile.

Result

Compiler enforces full implementation of interface methods.

This strict rule ensures classes follow the interface contract exactly.

3

Intermediate

Introducing default interface methods

🤔Before reading on: do you think interfaces can provide method code before C# 8.0? Commit to yes or no.

Concept: Interfaces can now include method bodies with default behavior.

Starting with C# 8.0, interfaces can have methods with default code: interface IAnimal { void Speak(); void Eat() { Console.WriteLine("Eating food"); } } Classes implementing IAnimal must write Speak but can skip Eat if the default is fine.

Result

Classes can inherit default method behavior from interfaces.

This breaks the old rule that interfaces only declare methods, enabling smoother interface evolution.

4

Intermediate

Overriding default interface methods

🤔Before reading on: if a class implements a default method, does it have to override it? Commit to yes or no.

Concept: Classes can override default interface methods to provide custom behavior.

Even if an interface provides a default method, a class can still write its own version: class Dog : IAnimal { public void Speak() { Console.WriteLine("Woof!"); } public void Eat() { Console.WriteLine("Dog eats bones"); } } Here, Dog replaces the default Eat method.

Result

Custom behavior overrides interface defaults when needed.

This flexibility lets classes choose between default and custom implementations.

5

Intermediate

Interface versioning with default methods

🤔Before reading on: do you think adding a new method to an interface breaks old classes? Commit to yes or no.

Concept: Default methods allow adding new interface methods without breaking existing code.

Previously, adding a method to an interface forced all implementers to update. With default methods: interface IAnimal { void Speak(); void Eat() { Console.WriteLine("Eating food"); } void Sleep() { Console.WriteLine("Sleeping"); } } Old classes still compile because Sleep has a default.

Result

Interfaces can evolve safely over time.

This solves a major maintenance problem in large projects and libraries.

6

Advanced

Multiple inheritance and default methods

🤔Before reading on: if two interfaces have the same default method, which one does a class use? Commit to your guess.

Concept: When multiple interfaces provide the same default method, classes must resolve conflicts explicitly.

If a class implements two interfaces with the same default method: interface IA { void Show() { Console.WriteLine("IA Show"); } } interface IB { void Show() { Console.WriteLine("IB Show"); } } class C : IA, IB { public void Show() { // Must choose which default to call or provide own ((IA)this).Show(); // or ((IB)this).Show() } } The compiler forces the class to clarify which method to use.

Result

Conflict resolution is required for ambiguous defaults.

Understanding this prevents confusing bugs in complex interface hierarchies.

7

Expert

Performance and runtime behavior of default methods

🤔Before reading on: do you think default interface methods are compiled into classes or called via interface dispatch? Commit to your answer.

Concept: Default interface methods are called via interface dispatch and can affect performance and versioning.

At runtime, calls to default interface methods use the interface's method table, not the class's. This means: - Calls go through a virtual dispatch. - Classes don't get compiled copies of default methods. - This allows updating interface defaults without recompiling classes. However, this can add a small overhead compared to direct class methods.

Result

Default methods enable flexible updates but may impact call speed slightly.

Knowing the runtime dispatch helps optimize and debug interface method calls.

Under the Hood

Default interface methods are stored in the interface's method table (vtable). When a class does not override a default method, calls to that method are dispatched through the interface's vtable at runtime. This allows the interface to provide behavior without requiring the class to implement it. The runtime uses a special dispatch mechanism to find the default method implementation if the class lacks one.

Why designed this way?

This design allows interfaces to evolve by adding new methods with default implementations without breaking existing classes. It avoids forcing recompilation of all implementers and supports backward compatibility. Alternatives like abstract base classes were less flexible because they require inheritance and can limit multiple inheritance scenarios.

┌───────────────┐       ┌───────────────┐
│   Interface   │       │   Class C     │
│  Method Table │◄──────┤  Method Table │
│ ┌───────────┐ │       │ ┌───────────┐ │
│ │ Default   │ │       │ │ Overrides │ │
│ │ MethodB() │ │       │ │ MethodA() │ │
│ └───────────┘ │       │ └───────────┘ │
└───────────────┘       └───────────────┘
         ▲                      ▲
         │                      │
         └───── Dispatch ───────┘

Myth Busters - 4 Common Misconceptions

Quick: Do default interface methods force all classes to override them? Commit to yes or no.

Common Belief: All classes must override default interface methods to use them.

Reality: Classes can choose to use the default implementation without overriding it.

Why it matters: Thinking all classes must override leads to unnecessary code duplication and confusion.

Quick: Can default interface methods have state (fields)? Commit to yes or no.

Common Belief: Default interface methods can have fields to store data like classes.

Reality: Interfaces cannot have instance fields; default methods can only use static fields or parameters.

Why it matters: Expecting state in interfaces causes design errors and misunderstanding of interface roles.

Quick: If two interfaces have the same default method, does the compiler pick one automatically? Commit to yes or no.

Common Belief: The compiler automatically chooses which default method to use when there is a conflict.

Reality: The compiler forces the class to explicitly resolve conflicts; it does not pick automatically.

Why it matters: Assuming automatic resolution can cause runtime ambiguity and compilation errors.

Quick: Do default interface methods improve performance by inlining code? Commit to yes or no.

Common Belief: Default interface methods make calls faster because they are inlined into classes.

Reality: Calls to default interface methods go through interface dispatch and may be slightly slower than direct calls.

Why it matters: Misunderstanding performance can lead to wrong optimization decisions.

Expert Zone

1

Default interface methods can be used to provide extension points in libraries without breaking existing implementations.

2

Explicit interface implementation can still be combined with default methods to control method visibility and dispatch.

3

Default methods do not support instance fields, so stateful behavior must be managed carefully, often via extension methods or external classes.

When NOT to use

Avoid default interface methods when you need to maintain strict separation of interface and implementation or when performance is critical and virtual dispatch overhead is unacceptable. Use abstract base classes or composition instead for stateful or complex behavior.

Production Patterns

In large frameworks, default interface methods enable adding new features to interfaces without forcing all consumers to update. They are often combined with extension methods and explicit interface implementations to provide flexible APIs that evolve safely.

Connections

Abstract base classes

Alternative approach to sharing code with interfaces

Understanding default interface methods clarifies when to use interfaces versus abstract classes for code reuse and API design.

Multiple inheritance in C++

Similar problem of method conflicts and resolution

Knowing how C# resolves default method conflicts helps understand multiple inheritance complexities in other languages.

Legal contracts

Interfaces as contracts with optional clauses

Seeing interfaces as contracts with default clauses helps grasp how default methods allow optional behavior without breaking agreements.

Common Pitfalls

#1 Assuming all interface methods must be implemented manually.

Wrong approach:

interface IExample {
void DoWork() { Console.WriteLine("Default work"); }
}

class Worker : IExample {
// No DoWork method implemented
}

// Usage
Worker w = new Worker();
w.DoWork(); // Error: method not found

Correct approach:

interface IExample {
void DoWork() { Console.WriteLine("Default work"); }
}

class Worker : IExample {
// No override needed
}

// Usage
IExample w = new Worker();
w.DoWork(); // Prints "Default work"

Root cause:

Calling default interface methods requires using the interface type, not the class type directly.

#2 Ignoring conflict resolution when multiple interfaces have the same default method.

Wrong approach:

interface IA {
void Show() { Console.WriteLine("IA"); }
}
interface IB {
void Show() { Console.WriteLine("IB"); }
}
class C : IA, IB {
// No Show method implemented
}

C c = new C();
c.Show(); // Compiler error: ambiguous

Correct approach:

class C : IA, IB {
public void Show() {
((IA)this).Show(); // or ((IB)this).Show()
}
}

Root cause:

The compiler cannot decide which default method to use without explicit override.

#3 Trying to add instance fields to interfaces for default methods.

Wrong approach:

interface IStateful {
int counter = 0; // Error: interfaces cannot have instance fields
void Increment() {
counter++;
}
}

Correct approach:

interface IStateful {
static int counter = 0; // static fields allowed
void Increment() {
counter++;
}
}

Root cause:

Interfaces are contracts without instance state; default methods cannot hold per-object data.

Key Takeaways

Default interface methods let interfaces provide method implementations, reducing the need for all implementers to write the same code.

They enable interfaces to evolve by adding new methods without breaking existing classes, improving software maintainability.

Classes can override default methods to customize behavior or use the interface's default when suitable.

Conflicts from multiple default methods require explicit resolution to avoid ambiguity.

Default interface methods use interface dispatch at runtime, which affects performance and versioning behavior.