Why Interface support multiple inheritance and class doesnt in c# [duplicate]

I'd be very interested in a more authoritative answer, but here's my take.

In languages that support multiple inheritance, the key ambiguity that is (arguably) unsatisfactorily resolved is what happens when you subclass from two types that both define a method with the same signature. For example:

public class BaseClass1 
{
    public string SomeMethod() 
    {
        return "Implementation1";
    }
}

public class BaseClass2 
{
    public string SomeMethod() 
    {
        return "Implementation2";
    }
}

public class MySuclass : BaseClass1, BaseClass2 
{
}

Now what does the following return?

MySubclass mySubclass = new MySubclass();
string s = mySubclass.SomeMethod();

In C#, explicit interface implementation allows you to easily resolve this by definining both. After converting BaseClass1 and BaseClass2 to interfaces, we can have

public class MySuclass : IBaseClass1, IBaseClass2 
{
    string IBaseClass1.SomeMethod()
    {
        return "Implementation1";
    }

    string IBaseClass2.SomeMethod()
    {
        return "Implementation2";
    }
}

The key of course being that there is no ambiguity with this syntax as it's not possible to access SomeMethod without first casting the target to either IBaseClass1 or IBaseClass2.