Working With Default Interface Implementation In C# 8.0

interface ILogger
{
    void Log(LogLevel level, string message);
    void Log(Exception ex) => Log(LogLevel.Error, ex.ToString());
}
class CustomLogger : ILogger
{
    public void Log(LogLevel level, string message)
    {
        Console.WriteLine($"{level.ToString()}: Hello readers of C# 8!! {message}");
    }
}
class DefaultInterfaceImpl
{
    public static void DoDivide()
    {
        try
        {
            int a = 3;
            int b = 0;
            int c = a / b;
        }
        catch (DivideByZeroException ex)
        {
            ILogger logger = new CustomLogger(); // Converting to interface
            logger.Log(ex); // Calling new Log overload
        }
    }
}

As you can see in the code above, the default interface member is invoked from the catch block despite the concrete class CustomLogger has not implemented it. Before calling the Log method, the class instance is converted to the ILogger interface.

Now let's try to call the Log method only with the CustomLogger class as follows.

CustomLogger logger2 = new CustomLogger();
logger2.Log(ex);

The above code will result in a compile-time error that "There is no argument given that corresponds to the required formal parameter 'message' of 'CustomLogger.Log(LogLevel, string)" simply because the CustomLogger class has no information about default interface members.

Now, let's go a little deeper on the internals of default interface implementation and have a look at the modified interface as follows.

interface ILogger2
{
    abstract void Log(LogLevel level, string message);
    virtual void Log(Exception ex) => Log(LogLevel.Error, ex.ToString());
}

The above code will give compile-time errors in previous versions of C# 8 as follows.

This code will perfectly compile in C# 8, and the reason is in C# 8, regular interface members are classified as abstract, and default interface members are designed as virtual, and hence declaring them as abstract or virtual doesn't throw any error.

Making default interface members virtual gives the flexibility to extend their implementations based on the requirement.

To have a look at the same in action, let's add a new class by implementing the ILogger2 interface as follows.

class CustomLogger2 : ILogger2
{
    public void Log(LogLevel level, string message)
    {
        Console.WriteLine($"{level.ToString()}: Hello readers of C# 8!! {message}");
    }

    public void Log(Exception message)
    {
        Console.WriteLine($"From: Overridden method: Hello readers of C# 8!! {message}");
    }
}

And add a new method in an existing class DefaultInterfaceImpl as following.

public static void DoDivide2()
{
    try
    {
        int a = 3;
        int b = 0;
        int c = a / b;
    }
    catch (DivideByZeroException ex)
    {
        ILogger2 logger = new CustomLogger2(); // Converting to interface
        logger.Log(ex); // Calling new Log overload
    }
}

Upon running the above code, the overridden version of Log method (Inside CustomLogger2) will be called and the message "From: Overridden method: Hello readers of Learning C# 8!!" will be printed.

You might have noticed that override keyword has not been added in Log method in CustomLogger2 class and this differentiates with the regular virtual and override.

Summary

Default interface implementation is the most awaited feature that has been added as part of C# 8. It helps to add default implementation without disturbing existing contracts.

You can also have a look at the complete code in the attached zip file to go through and execute.

Hope you have liked the article. Please share your comments or suggestions.