C# Diamond-Inheritance(接口(interface)实现)

Question

如果一个类从两个单独的接口(interface)实现一个接口(interface)，它的行为是否就好像它只实现了一次一样？

例子:

public interface IAnimal { /* ... */ }
public interface IFullAnimal : IAnimal { /* ... */ }

public interface IBear : IAnimal { /* ... */ }
public interface IFullBear : IBear, IFullAnimal { /* ... */ }

// and implementing IFullBear:
public class FullBear : IFullBear { /* ... */ }

上面，FullBear 通过 IFullBear 从 IFullAnimal 和 IBear 实现了 IAnimal .这是否引入了任何关于 IAnimal 实现的奇怪行为 ，因为 IFullAnimal 和 IBear 都没有提供关于 IAnimal 实现的任何信息(因为语言不允许这样做)。

Answer 1

不会，这是一种非常常见且无害的情况。 System.Collections.Generic命名空间是类似“冗余”接口(interface)声明的一个很好的例子:

 public class List<T> : IList<T>, 
                        System.Collections.IList,
                        IReadOnlyList<T>

两者都是 IList<T>和 IReadOnlyList<T>显然执行IEnumerable<T>世界还没有结束。

不要将此与界面重新实现混淆，后者确实会改变行为:

interface IFoo
{
    void Foo();
}

class Base: IFoo
{
     public void Foo() { Console.WriteLine("Base Foo!");
}

class Derived: Base { }

class DerivedWithATwist: Base, IFoo //redeclares interface
{
    void IFoo.Foo() { Console.WriteLine("Derived Foo!");
}

现在，

IFoo foo = new Base();
IFoo derived = new Derived();
IFoo derivedWithATwist = new DerivedWithATwist();

foo.Foo(); //Base Foo!
derived.Foo(); //Base Foo!
derivedWithATwist.Foo(); //Derived Foo!
(derivedWithATwist as Base).Foo(); //Base Foo!  !!!