Topic 8224 min readStructured Tutorial

Default Interface Methods in C#

Quick Answer

Default Interface Methods in C# allow interfaces to provide method implementations directly, enabling backward-compatible interface evolution without breaking existing implementations. Introduced in C# 8.0, this feature helps add new functionality to interfaces while maintaining compatibility.

Learning Objectives

Explain the purpose of Default Interface Methods in a practical learning context.
Identify the main ideas, terms, and decisions involved in Default Interface Methods.
Apply Default Interface Methods in a simple real-world scenario or practice task.

Introduction

Interfaces in C# define contracts that classes or structs must implement. Traditionally, interfaces could only declare method signatures without any implementation.

Default Interface Methods, introduced in C# 8.0, allow interfaces to provide default implementations for methods. This helps evolve interfaces without breaking existing code.

Interface evolution without breaking existing implementations.

What Are Default Interface Methods?

Default Interface Methods let you add method implementations inside interfaces. This means interfaces can now contain method bodies.

This feature enables adding new methods to interfaces without forcing all implementing classes to update their code immediately.

Introduced in C# 8.0
Allows method bodies inside interfaces
Supports backward-compatible interface evolution
Helps avoid breaking changes in large codebases

How to Define Default Interface Methods

You define a default interface method by providing a method body directly inside the interface.

Implementing classes can either use the default implementation or override it with their own.

Example of Default Interface Method

Below is a simple example showing an interface with a default method implementation.

Benefits of Default Interface Methods

Default Interface Methods provide several advantages in software design and maintenance.

Enable adding new methods to interfaces without breaking existing implementations.
Reduce the need for creating new interfaces or abstract classes.
Simplify API evolution in large projects.
Allow shared code in interfaces, reducing duplication.

Limitations and Considerations

While powerful, default interface methods have some limitations and should be used thoughtfully.

Not supported in all C# versions; requires C# 8.0 or later.
Can complicate interface design if overused.
May introduce ambiguity if multiple interfaces provide the same default method.
Not a replacement for abstract classes in all scenarios.

Practical Example

This example shows an interface ILogger with a default method LogWarning. The ConsoleLogger class implements ILogger and inherits the default LogWarning method without overriding it.

Examples

Default Interface Method Example

public interface ILogger
{
    void Log(string message);

    // Default method implementation
    void LogWarning(string message)
    {
        Log("Warning: " + message);
    }
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

// Usage
ILogger logger = new ConsoleLogger();
logger.LogWarning("Disk space low.");

This example shows an interface ILogger with a default method LogWarning. The ConsoleLogger class implements ILogger and inherits the default LogWarning method without overriding it.

Best Practices

Use default interface methods sparingly to keep interfaces simple and clear.
Prefer default methods for backward compatibility when evolving interfaces.
Avoid complex logic inside default interface methods.
Document default implementations clearly for interface consumers.
Test default methods thoroughly to ensure expected behavior.

Common Mistakes

Assuming default interface methods replace abstract classes entirely.
Overusing default methods leading to bloated interfaces.
Ignoring potential method conflicts when implementing multiple interfaces with default methods.
Using default methods to add state or fields, which is not allowed.

Hands-on Exercise

Implement a Default Interface Method

Create an interface with a default method that provides a greeting message. Implement the interface in a class and use both the default and overridden methods.

Expected output: Console output showing both default and overridden greeting messages.

Hint: Define a method with a body inside the interface and override it in the class.

Interview Questions

What are Default Interface Methods in C#?

Interview

Default Interface Methods allow interfaces to provide method implementations directly, enabling interface evolution without breaking existing implementations. They were introduced in C# 8.0.

Why were Default Interface Methods introduced in C#?

Interview

They were introduced to allow adding new methods to interfaces without forcing all existing implementations to update, thus supporting backward compatibility and easier API evolution.

Can default interface methods have state or fields?

Interview

No, interfaces cannot have fields or state. Default interface methods can only provide method implementations without storing state.