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

Question

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

Answer 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 {}

Answer 2

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

Answer 3

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

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

Answer 4

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

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

Answer 5

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

Answer 6

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

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();
    }
}

Answer 7

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