Can an Interface Have Concrete Methods in C#?

Yes, an interface can have concrete methods in C#, but this capability was introduced with C# 8.0. Prior to C# 8.0, interfaces could only declare members (methods, properties, events, indexers) but not provide implementations for them.

Evolution of Interfaces in C

Historically, the primary purpose of an interface in C# was to define a contract without providing any implementation details. This meant that any class or struct implementing the interface was solely responsible for providing the concrete implementation for all declared members.

• Before C# 8.0: Interfaces strictly adhered to the principle of "declaration only." They served as pure contracts, ensuring that implementing types provided their own logic. As per traditional understanding, an interface could only declare methods and properties but could not implement them, nor could it hold state (instance fields).

• C# 8.0 and Later: Default Interface Methods: C# 8.0 introduced a significant feature called Default Interface Methods. This allows interfaces to provide a concrete implementation for methods directly within the interface definition. This feature enables backward compatibility for interfaces by allowing new methods to be added without breaking existing implementations.

What are Default Interface Methods?

Default interface methods provide a base implementation for a method that any implementing class can choose to use or override. This is particularly useful for:

• Non-Breaking Changes: Adding new methods to an existing interface without forcing all existing implementations to update immediately. Implementing classes can continue to compile, inheriting the default implementation, or choose to provide their own.
• Providing Common Functionality: Offering a default behavior for a method that is common across many implementations, reducing code duplication.

Example of a Default Interface Method:

public interface ILogger
{
    // An abstract method (no implementation)
    void Log(string message);

    // A concrete method with a default implementation (introduced in C# 8.0)
    void LogWarning(string warningMessage)
    {
        Log($"[WARNING]: {warningMessage}");
    }

    // Another concrete method (can call other interface methods)
    void LogError(string errorMessage)
    {
        Log($"[ERROR]: {errorMessage}");
    }
}

// Example class implementing the interface
public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
    // ConsoleLogger can use the default LogWarning and LogError,
    // or override them if needed.
}

// Usage
ConsoleLogger logger = new ConsoleLogger();
logger.Log("This is a regular message."); // Calls ConsoleLogger's Log
logger.LogWarning("Something potentially problematic happened."); // Calls default LogWarning
logger.LogError("Critical error encountered!"); // Calls default LogError

In this example, LogWarning and LogError have concrete implementations within the ILogger interface itself. Implementing classes like ConsoleLogger only must implement Log.

Key Characteristics of Interfaces with Default Methods

Even with the introduction of default methods, interfaces retain several core characteristics:

• No Instance Fields: Interfaces still cannot declare instance fields to maintain state. They are stateless.
• No Constructors: Interfaces cannot have constructors.
• Multiple Inheritance of Implementation: While C# classes don't support multiple inheritance of implementation, interfaces with default methods allow a form of "multiple inheritance" of behavior, as a class can implement multiple interfaces, each providing default method implementations.
• Accessibility: Members within an interface (including default methods) can now have access modifiers like public, private, protected, internal, and static, which was not possible before C# 8.0 where members were implicitly public and abstract.

Interface vs. Abstract Class

While default interface methods introduce a similarity to abstract classes (both can have abstract and concrete methods), fundamental differences remain:

For more details on C# interfaces and their capabilities, you can refer to the official Microsoft documentation on interfaces: C# Interfaces Documentation