Does default implementation of Interface members in C# 8 relates to overcome multiple inheritance problem of abstract class?

Question

I'm reading this blog of .NET Engineering Team and they have introduced a new feature of default implementation for Interface. I'm confused related to its motive other than multiple level inheritance problem of abstract class. Other than that I'm not able to figure out any other benefit. Consdier the following code:

C# 7 (Not possible to provide method definitions)

interface ILogger
{        
    void LogData(dynamic data, dynamic logMode);

    bool SendStatusEmail(string emailAddress);

}
public class EmployeeLog : ILogger
{
    public void LogData(dynamic data, dynamic logMode)
    {
        throw new NotImplementedException();
    }

    public bool SendStatusEmail(string emailAddress)
    {
        throw new NotImplementedException();
    }
}

public abstract class Logger
{
    public abstract void LogData(dynamic data, dynamic logMode);

    public bool SendStatusEmail(string emailAddress)
    {
        // Email Sending Code
        return true;
    }
}

public class EmployeeLog : Logger
{
    public override void LogData(dynamic data, dynamic logMode)
    {
        throw new NotImplementedException();
    }
}

C# 8 (Possible to provide method definitions)

interface ILogger
{
    void LogData(dynamic data, dynamic logMode);

    public bool SendStatusEmail(string emailAddress)
    {
        // Email Sending Code
        return true;
    }

}
public class EmployeeLog : ILogger
{
    public void LogData(dynamic data, dynamic logMode)
    {
        throw new NotImplementedException();
    }
}

public abstract class Logger
{
    public abstract void LogData(dynamic data, dynamic logMode);

    public bool SendStatusEmail(string emailAddress)
    {
        // Email Sending Code
        return true;
    }
}

public class EmployeeLog : Logger
{
    public override void LogData(dynamic data, dynamic logMode)
    {
        throw new NotImplementedException();
    }
}

In C# 8, both abstract class and interface can do the same work of providing default implementation to its members. I have following doubts related to it:

• If Interface provides default implementation and also supports multiple inheritance, what is the need to abstract class in c# 8?

• What will happen in case of this scenario?

:

interface ILogger
{
   public bool SendStatusEmail(string emailAddress)
{
    // Email Sending Code
    return true;
  }
}
interface IEmail
{
    public bool SendStatusEmail(string emailAddress)
    {
        // Email Sending Code
        return true;
    }

}

public class EmployeeLog : ILogger, IEmail
{
}

public class Test
{
    EmployeeLog emp = new EmployeeLog();
    emp.SendStatusEmail();  //Which function it will refer to?
}

Answer 1

Answer: Abstract classes can have fields and virtual methods

This is why multiple inheritance is not supported in C# (also in Java)

Fields with multiple inheritance may cause issues when:

class A : B, C {...}
class C : D {...}
class B : D {...}
class D
{
    ...
    protected int _value;
    ...
}

Should the inherited B and C share the same instance of _value?

There are reasons to both.

If so, the logics in B and C could interfere with each other because the value of _value is neither predictable for B nor for C.

And B and C do not even know that they would work with each other as parts of the same object.

If not, which instance of _value should be accessed from A?

Similar issues apply to virtual methods. Because the virtual table would be no longer linear when both B and C override a virtual method defined in D.

Solving these would make the inheritance relationship very complex, therefore Java does not support multiple inheritance and introduced the concept of interface, and this also came to C#.

How interface solved this problem

There are only method declarations (regarding properties as accessors as methods) in interface definitions, so there could not be fields and method overridings. So there are no multiple inheriting issues.

How C# 8.0 can allow interfaces to have method bodies without causing these issues

Default implementation in C# 8.0 does not use the same logic as the virtual table in class inheritance logics, but a priority mechanism that chooses the implementation from the nearest implemented interface to be the only available implementation, therefore there are no virtual table issues.

There are still no fields allowed in interfaces therefore there are no field issues.

How to choose between interface with default implementations and abstract classes

• Syntactically, if the type must have fields or virtual/abstract methods with multiple overrides in use, from the types in the inheritance tree, use abstract class, otherwise interface.

• Logically, if the main part of logic should be implemented in this type and some single details are to be specified within the derived/implementation class, use abstract class. If the type only specifies how it could be accessed and the implemented methods are simply making convenience for the implementation class, like converting an argument from an alternative type to the mainly implemented type, use interface with default implementations.