Как использование интерфейсов преодолевает проблему множественного наследования в С#?

Ответ 1

Один класс может реализовать любое количество интерфейсов, даже если эти интерфейсы также расширяют и другие интерфейсы. Множественное наследование невозможно только с классами.

// This is not allowed
class A { void A() {} }
class B { void B() {} }
class C : A, B {}

// This is allowed
interface IA { void A(); }
interface IB { void B(); }

class A : IA, IB
{
    public void A() {}
    public void B() {}
}

Проблема с алмазом существует с классами, потому что существует возможность столкновения реализаций (если A и B имеют один и тот же метод, а C расширяет оба метода, какой метод требуется?). С другой стороны, интерфейсы просто требуют, чтобы тип реализации имел методы, которые они объявляют.

Если тот же самый метод определен в двух интерфейсах, а класс реализует оба интерфейса, это не имеет значения. Все, что нужно сделать классу, это обеспечить реализацию метода, чтобы код мог быть написан для вызова этого метода. Значит, это работает:

interface IA { void Method(int x); }
interface IB { void Method(int x); }

class A : IA, IB
{
    public void Method(int x)
    {
        Console.WriteLine(x);
    }
}

Обратите внимание, что класс может по-прежнему наследовать от другого класса плюс любое количество интерфейсов:

class A : B, IA, IB {}

Ответ 2

"Проблема с алмазами" отсутствует при использовании интерфейсов, потому что не существует двусмысленной реализации. Прочтите статью статью Википедии, в которой содержится полное объяснение.

Ответ 3

Несколько интерфейсов не будут создавать проблему с алмазом, потому что каждый класс должен предоставить свою собственную уникальную реализацию, а это означает, что нет совместного использования ресурсов.

С# не допускает множественного наследования, потому что они заботятся о вас, и сделали язык максимально возможным для стрельбы.

Ответ 4

Вы можете наследовать только один класс и неограниченное количество интерфейсов за один раз

Ответ 5

Я думаю, что это несправедливо думать об этом только в рамках C#.

CLR сам не поддерживает множественное наследование. Может быть, потому, что они хотели поддерживать другие языки, которые в настоящее время не поддерживают его или не могут поддерживать его в будущем.

Ответ 6

Если вы спросите о наследовании: класс может наследовать только один класс, но может реализовать любое количество интерфейсов. См. эту статью о наследовании и полиморфизме в С#.

Ответ 7

Это возможный способ попытаться достичь чего-то, что вы обычно можете достичь с помощью множественного наследования.

interface IA
{
    void DoAnything(string name);
}

class A : IA
{
    public void DoSomething()
    {
        // some code
    }
    public void DoAnything(string name)
    {
        // Some code
    }
}

class B : IA
{
    public void DoNothing()
    {
        // Some code
    }

    public void DoAnything(string name)
    {
        // Some code
    }
}

class StorageCache : IA
{
    private A ObjA;
    private B ObjB;

    public void DoAnything(string name)
    {
        ObjA.DoAnything(name);
        ObjB.DoAnything(name);
    }
    public void DoNothing()
    {
        ObjB.DoNothing();
    }
    public void DoSomething()
    {
        ObjA.DoSomething();
    }
}