According to https://blogs.msdn.microsoft.com/dotnet/2018/11/12/building-c-8-0/, one of the new features coming in C# 8 is the default implementation of interfaces. Will this new feature also implicitly allow for multiple inheritance? If not, what exactly will happen if I try the following:
public interface A { int Foo() => 1; }
public interface B { int Foo() => 2; }
public class C : A, B { }
Your question is answered by Mads Torgersen in the blog post you linked to:
Actually interfaces are still quite far from abstract classes. Classes don’t inherit members from interfaces, so if a class leaves a member M implemented by the interface, the class does not have a member M! It’s like an explicit implementation today; you have to convert to the interface in order to get at such members.
So with your example:
public interface A { int Foo() => 1; }
public interface B { int Foo() => 2; }
public class C : A, B { }
You cannot do this:
var something = new C();
var x = something.Foo(); /* does not compile */
You can do the following:
var something = new C();
var x = ((A)something).Foo(); /* calls the implementation provided by A */
var y = ((B)something).Foo(); /* calls the implementation provided by B */
Credit to @CodeCaster for his/her great comments that prompted this answer.
The proposal states:
Note that a class does not inherit members from its interfaces; that is not changed by this feature:
Thus, it seems reasonable (although impossible to confirm with 100% certainty until it is shipped) that:
public interface A { int Foo() => return 1; }
public interface B { int Foo() => return 2; }
public class C : A, B { }
will work fine.
Just as the proposal shows:
new C().M(); // error: class 'C' does not contain a member 'M'
then we can assume, your version:
new C().Foo();
will also not compile.
The proposal shows:
IA i = new C();
i.M();
as valid, which is equivalent to your:
A i = new C();
i.Foo();
Since i is declared as type A there is no reason to assume the same would not work if A was changed to B - there are no collisions to speak of.
The entire point of this feature is to allow interfaces to be extended in a safe way (see this video). If this only worked if you implemented one interface, that seems contrary to the objective of the feature. And given the feature appears to be implemented in a way roughly akin to explicit interface implementation (which is why we can't invoke C.Foo() directly), I think we can reasonably assume that it will most likely allow for multiple interface implementation.
C, will you be able to callC.Foo(), and which implementation will that call, or will it fail to compile becauseC.Foo()doesn't exist, or because no best overload can be matched?C.Fooas per my earlier comment. Now, your answer raises a great question (what if there is a third interface that 'inherits' the two of them?) - which is a great question, but a slightly different one.