Why does an interface's default implementation get called when two classes are in the inheritance chain, and the class in the middle is empty

Question

Summary

I have found that inserting a class between an interface and another derived class results in the interface's default implementation being called rather than the derived implementation for the same method. This is unexpected behavior. Why is this happening?

Example

I have created a sample project which reproduces the problem:

    public interface IPrinterInterface
    {
        public void PrintIt() => Console.WriteLine("Interface");
    }

    public class MiddlePrinter : IPrinterInterface{}

    public class Printer : MiddlePrinter
    {
        public void PrintIt() => Console.WriteLine("Class");
    }

    class Program
    {
        static void Main(string[] args)
        {
            var printer = (IPrinterInterface)new Printer();
            printer.PrintIt(); // This prints "Interface"
            Console.ReadLine(); // so the app sits
        }
    }

This code results in Interface being printed out.

To contrast, if the MiddlePrinter class is removed from the inheritance (as shown in the following code), then the code prints "Class":

    public interface IPrinterInterface
    {
        public void PrintIt() => Console.WriteLine("Interface");
    }

    public class Printer : IPrinterInterface
    {
        public void PrintIt() => Console.WriteLine("Class");
    }

    class Program
    {
        static void Main(string[] args)
        {
            var printer = (IPrinterInterface)new Printer();
            printer.PrintIt(); // This prints "Class"
            Console.ReadLine(); // so the app sits
        }
    }

I didn't expect to see this type of behavior, can someone explain why this is happening?

Platform

This has been reproduced in a .NET5 console application and a modern Xamarin Android application.

Answer 1

Classes do not inherit members from interfaces, not even with default implementations. Source.

Note that a class does not inherit members from its interfaces; that is not changed by this feature

As such, since MiddlePrinter does not contain an inherited member for Printer to override, the most concrete implementation of PrintIt() from IPrinterInterface's point of view is its own default implementation.

This is made evident by attempting to apply the override keyword to Printer.PrintIt(). You will get an error that no suitable method was found to override.

Without MiddlePrinter, Printer provides a more concrete implementation by replacing the default.

Answer 2

The reason is that when casting to an interface, it tries to find the first function that is in the same inheritance level as the interface or a lower inheritance level (same or parent class). Because you defined the functionality for the interface (default fallback function) it can't find a suitable function to override and simply reverts to the default function specified in the interface.

For example I've added another printer called Lower printer:

public interface IPrinterInterface
{
    // Default function if no parent functions are found.
    public void PrintIt() => Console.WriteLine("Interface");
}

public class LowerPrinter
{
    public void PrintIt() => Console.WriteLine("Lower");
}

public class MiddlePrinter : LowerPrinter, IPrinterInterface
{
}

public class Printer : MiddlePrinter
{
    public void PrintIt() => Console.WriteLine("Class");
}

internal class Program
{
    private static void Main(string[] args)
    {
        var printer = (IPrinterInterface)new Printer();
        printer.PrintIt(); // This prints "Lower"
        Console.ReadLine(); // so the app sits
    }
}

But now if I extend it further:

public class BasePrinter
{
    public void PrintIt() => Console.WriteLine("Base");
}

public class LowerPrinter : BasePrinter
{
    public void PrintIt() => Console.WriteLine("Lower");
}

It will still print Lower because it is the first suitable function found. The reason it can't search in the children or derived classes is because there is no guarantee the function will in those classes. You might be thinking "but how since they inherit?" - Because if the child class has a function with the same name - it hides the parent method - not implement it.