Implementing interfaces in C Sharp (C#) - Deep Dive

Overview - Implementing interfaces

What is it?

An interface in C# is like a contract that defines a set of methods and properties without any implementation. When a class implements an interface, it promises to provide the code for all those methods and properties. This helps different classes share the same set of behaviors while keeping their own unique details. Interfaces let you write flexible and organized code that can work with many types of objects in the same way.

Why it matters

Without interfaces, it would be hard to make different parts of a program work together smoothly because each class might have different method names or ways to do things. Interfaces solve this by setting clear rules that many classes can follow, making code easier to understand, change, and reuse. This is especially important in big programs or teams where many people write code that must fit together.

Where it fits

Before learning interfaces, you should understand classes, methods, and basic object-oriented programming concepts like inheritance. After mastering interfaces, you can explore advanced topics like polymorphism, dependency injection, and design patterns that rely on interfaces for flexible code design.

Mental Model

Core Idea

An interface is a promise that a class will provide certain behaviors, allowing different classes to be used interchangeably based on shared capabilities.

Think of it like...

Think of an interface like a job description that lists tasks someone must do, but not how to do them. Different people (classes) can have the same job description but perform the tasks in their own way.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│   Interface   │──────▶│   Class A     │
│  (Contract)   │       │ (Implements)  │
│ - Method1()   │       └───────────────┘
│ - Method2()   │               ▲
└───────────────┘               │
                               │
                       ┌───────────────┐
                       │   Class B     │
                       │ (Implements)  │
                       └───────────────┘

Build-Up - 7 Steps

1

Foundation

What is an interface in C#

Concept: Introduce the basic idea of an interface as a contract with method signatures but no code.

In C#, an interface is declared using the 'interface' keyword. It only contains method and property declarations without any implementation. For example: interface IAnimal { void Speak(); } This means any class that implements IAnimal must have a Speak method.

Result

You understand that interfaces define what methods a class must have, but not how they work.

Knowing that interfaces only declare methods helps you see them as promises, not actual code.

2

Foundation

Implementing an interface in a class

Concept: Show how a class uses the interface keyword to promise it will provide the methods declared in the interface.

To implement an interface, a class adds ': InterfaceName' after its name and writes all the methods the interface requires. Example: class Dog : IAnimal { public void Speak() { Console.WriteLine("Woof!"); } } Here, Dog promises to have a Speak method as IAnimal requires.

Result

The Dog class now follows the IAnimal contract and can be used wherever IAnimal is expected.

Understanding that implementing an interface means fulfilling a contract helps you design classes that fit expected roles.

3

Intermediate

Multiple interfaces on one class

🤔Before reading on: Do you think a class can implement more than one interface at the same time? Commit to your answer.

Concept: Explain that a class can promise to follow many contracts by implementing multiple interfaces.

In C#, a class can implement several interfaces separated by commas. For example: interface IWalker { void Walk(); } class Robot : IAnimal, IWalker { public void Speak() { Console.WriteLine("Beep boop"); } public void Walk() { Console.WriteLine("Robot walking"); } } Robot must provide all methods from both IAnimal and IWalker.

Result

Robot can be treated as both an IAnimal and an IWalker, showing flexible behavior.

Knowing that classes can implement multiple interfaces allows you to mix different capabilities cleanly.

4

Intermediate

Interface vs abstract class differences

🤔Before reading on: Do you think interfaces can have method code like abstract classes? Commit to your answer.

Concept: Clarify how interfaces differ from abstract classes in C#, especially about implementation and inheritance.

Abstract classes can have method code and fields, while interfaces only declare methods and properties without code (until recent C# versions). Also, a class can inherit only one abstract class but can implement many interfaces. This makes interfaces more flexible for defining shared behaviors.

Result

You can decide when to use interfaces for flexible contracts and abstract classes for shared code.

Understanding these differences helps you choose the right tool for designing your program's structure.

5

Intermediate

Explicit interface implementation

🤔Before reading on: Can a class implement two interfaces with methods of the same name differently? Commit to your answer.

Concept: Introduce explicit interface implementation to handle method name conflicts from multiple interfaces.

When two interfaces have methods with the same name, a class can implement them explicitly to avoid confusion: interface IFirst { void Show(); } interface ISecond { void Show(); } class Demo : IFirst, ISecond { void IFirst.Show() { Console.WriteLine("First Show"); } void ISecond.Show() { Console.WriteLine("Second Show"); } } You call these methods by casting the object to the interface type.

Result

Demo class can provide different code for each Show method, avoiding conflicts.

Knowing explicit implementation solves method name clashes lets you design complex interfaces safely.

6

Advanced

Interfaces with default implementations

🤔Before reading on: Do you think interfaces can provide method code in modern C#? Commit to your answer.

Concept: Explain that since C# 8.0, interfaces can have default method implementations, changing how interfaces work.

Modern C# allows interfaces to include method bodies with default code: interface ILogger { void Log(string message) { Console.WriteLine("Default log: " + message); } } Classes can use this default or override it. This helps add new methods to interfaces without breaking existing code.

Result

Interfaces become more powerful and flexible, blending some features of abstract classes.

Understanding default implementations helps you maintain and evolve interfaces in large projects.

7

Expert

Performance and interface dispatch details

🤔Before reading on: Do you think calling a method via an interface is as fast as calling a class method directly? Commit to your answer.

Concept: Reveal how interface method calls are handled at runtime and their performance implications.

When you call a method through an interface, the runtime uses a special lookup called 'interface dispatch' to find the right method. This is slightly slower than calling a class method directly because it involves extra steps. However, modern runtimes optimize this well. Understanding this helps when writing performance-critical code.

Result

You know when interface use might affect speed and when it is negligible.

Knowing the runtime cost of interface calls helps you balance design flexibility with performance needs.

Under the Hood

At runtime, when a method is called through an interface reference, the .NET runtime uses a lookup table called the interface dispatch table to find the actual method implementation in the class. This allows different classes to provide their own versions of the method while the caller uses the interface type. The class's method implementations are stored in a virtual method table, and the interface dispatch connects the interface method call to the correct class method.

Why designed this way?

Interfaces were designed to separate the 'what' from the 'how' to allow flexible code reuse and polymorphism without forcing a class hierarchy. This design avoids the limitations of single inheritance and lets classes share behaviors across unrelated types. The dispatch mechanism balances flexibility with acceptable runtime performance.

┌───────────────┐          ┌───────────────┐
│ Interface ref │─────────▶│ Interface Vtbl│
└───────────────┘          └───────────────┘
                                   │
                                   ▼
                          ┌─────────────────┐
                          │ Class method ptr │
                          └─────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does implementing an interface automatically provide method code? Commit to yes or no.

Common Belief: Implementing an interface means the class automatically gets the methods' code from the interface.

Reality: Interfaces only declare methods; the class must write the actual code for each method.

Why it matters: Assuming code is provided leads to missing method implementations and compile errors.

Quick: Can a class inherit from multiple classes in C#? Commit to yes or no.

Common Belief: Since a class can implement multiple interfaces, it can also inherit from multiple classes.

Reality: C# allows only single class inheritance but multiple interface implementations.

Why it matters: Confusing this causes design mistakes and compilation failures.

Quick: Does explicit interface implementation make methods public? Commit to yes or no.

Common Belief: Explicitly implemented interface methods are public and can be called directly on the class instance.

Reality: Explicit interface methods are not accessible through the class instance directly; they require casting to the interface.

Why it matters: Misunderstanding this leads to confusion when methods seem missing or inaccessible.

Quick: Do interface default implementations replace abstract classes? Commit to yes or no.

Common Belief: With default implementations, interfaces can do everything abstract classes can, so abstract classes are obsolete.

Reality: Abstract classes still provide features like fields and constructors that interfaces cannot, so both have distinct uses.

Why it matters: Ignoring abstract classes limits design options and can lead to poor architecture.

Expert Zone

1

Interfaces can be used to define capabilities that cut across unrelated class hierarchies, enabling composition over inheritance.

2

Explicit interface implementation can hide methods from the public API of a class, controlling how the class is used externally.

3

Default interface methods can introduce versioning flexibility but may complicate interface contracts and increase maintenance complexity.

When NOT to use

Avoid interfaces when you need to share code or state between classes; use abstract classes instead. Also, if performance is critical and interface dispatch overhead matters, consider direct class method calls or sealed classes.

Production Patterns

Interfaces are widely used for dependency injection, allowing swapping implementations without changing code. They enable mocking in tests and support plugin architectures where new behaviors can be added by implementing interfaces.

Connections

Polymorphism

Interfaces enable polymorphism by allowing different classes to be treated through a common interface type.

Understanding interfaces clarifies how polymorphism works in practice, letting you write code that works with many types interchangeably.

Design Patterns

Many design patterns like Strategy and Observer rely on interfaces to define roles and interactions between objects.

Knowing interfaces helps you recognize and implement common design patterns that improve code flexibility and maintainability.

Contract Law (Legal Domain)

Interfaces act like legal contracts specifying obligations without dictating methods, similar to how contracts define duties without prescribing exact actions.

Seeing interfaces as contracts helps appreciate their role in enforcing rules and expectations in software design.

Common Pitfalls

#1 Forgetting to implement all interface methods in a class.

Wrong approach:

class Cat : IAnimal {
// Missing Speak method implementation
}

Correct approach:

class Cat : IAnimal {
public void Speak() {
Console.WriteLine("Meow");
}
}

Root cause:

Misunderstanding that interfaces require full method implementation leads to compile errors.

#2 Trying to call an explicitly implemented interface method directly on the class instance.

Wrong approach:

Demo demo = new Demo();
demo.Show(); // Error: Show not accessible

Correct approach:

IFirst first = new Demo();
first.Show(); // Works

Root cause:

Not realizing explicit implementations are only accessible via the interface type causes confusion.

#3 Using interfaces to share code or fields between classes.

Wrong approach:

interface IShape {
int x;
void Draw() { Console.WriteLine("Drawing"); }
}

Correct approach:

abstract class Shape {
public int x;
public void Draw() { Console.WriteLine("Drawing"); }
}

Root cause:

Believing interfaces can hold code or data like classes leads to syntax errors and design flaws.

Key Takeaways

Interfaces define a set of methods and properties that classes must implement, acting as a contract without providing code.

Implementing interfaces allows different classes to be used interchangeably, enabling flexible and organized code.

A class can implement multiple interfaces, mixing different capabilities without the limits of single inheritance.

Explicit interface implementation helps resolve method name conflicts and controls method visibility.

Modern C# interfaces can have default method implementations, adding flexibility but requiring careful design.