У коллеги и меня есть несколько аргументов в отношении множественного наследования. Я говорю, что это не поддерживается, и он говорит, что это так. Итак, я думал, что попрошу мозг в сети.
Поддерживает ли С# несколько наследований?
Ответ 1
Нет, вместо этого используйте интерфейсы! ^. ^
Ответ 2
К сожалению, вы не можете наследовать multiple classes. Вы можете использовать интерфейсы или комбинацию one class and interface(s), в которых в подписи должны следовать имя класса (ов).
interface A { }
interface B { }
class Base { }
class AnotherClass { }
Возможные способы наследования:
class SomeClass : A, B { } // from multiple Interface(s)
class SomeClass : Base, B { } // from one Class and Interface(s)
Это не является законным:
class SomeClass : Base, AnotherClass { }
Ответ 3
С# 3.5 или ниже не поддерживает множественное наследование, но С# 4.0 может это сделать, используя, как я помню, Dynamics.
Ответ 4
Множественное наследование не поддерживается на С#.
Но если вы хотите "наследовать" поведение из двух источников, почему бы не использовать комбо:
-
Состав
и
-
Инъекция зависимостей
Существует основной, но важный принцип ООП, в котором говорится: "Оформите композицию над наследованием".
Вы можете создать класс следующим образом:
public class MySuperClass
{
private IDependencyClass1 mDependency1;
private IDependencyClass2 mDependency2;
public MySuperClass(IDependencyClass1 dep1, IDependencyClass2 dep2)
{
mDependency1 = dep1;
mDependency2 = dep2;
}
private void MySuperMethodThatDoesSomethingComplex()
{
string s = mDependency1.GetMessage();
mDependency2.PrintMessage(s);
}
}
Как вы можете видеть, зависимости (фактические реализации интерфейсов) вводятся через конструктор. Вы класс не знаете, как реализуется каждый класс, но он знает, как их использовать. Следовательно, существует свободная связь между участвующими здесь классами, но с той же степенью использования.
Сегодня тенденции показывают, что наследование является своего рода "из моды".
Ответ 5
Вы не можете выполнять множественное наследование в С# до 3.5. Я не знаю, как это работает на 4.0, поскольку я не смотрел на него, но @tbischel опубликовал ссылку, которую мне нужно прочитать.
С# позволяет выполнять "несколько реализаций" через интерфейсы, которые сильно отличаются от "множественного наследования"
Итак, вы не можете сделать:
class A{}
class B{}
class C : A, B{}
Но вы можете сделать:
interface IA{}
interface IB{}
class C : IA, IB{}
НТН
Ответ 6
Как и Java (из чего был получен косвенный вывод С#), С# не поддерживает множественное наследование.
То есть, данные класса (переменные-члены и свойства) могут быть унаследованы только от одного родительского базового класса. С другой стороны, поведение класса (методы-члены) может быть унаследовано от нескольких родительских базовых интерфейсов.
Некоторые эксперты, особенно Бертран Майер (которые, по мнению некоторых, являются одним из отцов объектно-ориентированного программирования), считают, что это дисквалифицирует С# (и Java, и все остальное) от "истинного" объектно-ориентированного языка.
Ответ 7
Собственно, это зависит от вашего определения наследования:
- вы можете наследовать реализацию (члены, т.е. данные и поведение) из одного класса, но
- вы можете наследовать интерфейсы из нескольких, ну, интерфейсов.
Это не то, что обычно подразумевается под термином "наследование", но также не совсем необоснованно определять его таким образом.
Ответ 8
С# не поддерживает множественное наследование классов, но вам разрешено наследовать/реализовывать любое количество интерфейсов.
Это незаконно (B, C, D и E - все классы)
class A : B, C, D, E
{
}
Это законно (IB, IC, ID и IE - все интерфейсы)
class A : IB, IC, ID, IE
{
}
Это законно (B - класс, IC, ID и IE - интерфейсы)
class A : B, IC, ID, IE
{
}
Состав над наследованием - это шаблон дизайна, который, кажется, благоприятен даже на языках, поддерживающих множественное наследование.
Ответ 9
Возможно, вы захотите сделать свой аргумент еще дальше и рассказать о шаблонах дизайна, и вы можете узнать, почему он хочет потрудиться, чтобы наследовать от нескольких классов в С#, если он даже мог
Ответ 10
Имитированный шаблон множественного наследования
http://www.codeproject.com/KB/architecture/smip.aspx
Ответ 11
Множественное наследование позволяет программистам создавать классы, которые объединяют аспекты нескольких классов и соответствующие им иерархии. Напр. С++ позволяет наследовать более чем один класс
В С# классам разрешено наследовать только один родительский класс, который называется одиночным наследованием. Но вы можете использовать интерфейсы или комбинацию одного класса и интерфейса (интерфейсов), где в подписи должны следовать имя класса (ов).
Пример:
Class FirstClass { }
Class SecondClass { }
interface X { }
interface Y { }
Вы можете наследовать, как показано ниже:
класс NewClass: X, Y {} В приведенном выше коде класс "NewClass" создается из нескольких интерфейсов.
класс NewClass: FirstClass, X {} В приведенном выше коде класс "NewClass" создается из интерфейса X и класса "FirstClass".
Ответ 12
Вы не можете наследовать несколько классов за раз. Но есть варианты сделать это с помощью интерфейса. См. Ниже код
interface IA
{
void PrintIA();
}
class A:IA
{
public void PrintIA()
{
Console.WriteLine("PrintA method in Base Class A");
}
}
interface IB
{
void PrintIB();
}
class B : IB
{
public void PrintIB()
{
Console.WriteLine("PrintB method in Base Class B");
}
}
public class AB: IA, IB
{
A a = new A();
B b = new B();
public void PrintIA()
{
a.PrintIA();
}
public void PrintIB()
{
b.PrintIB();
}
}
вы можете назвать их ниже
AB ab = new AB();
ab.PrintIA();
ab.PrintIB();
Ответ 13
В общем, вы не можете это сделать.
Рассмотрим эти интерфейсы и классы:
public class A { }
public class B { }
public class C { }
public interface IA { }
public interface IB { }
Вы можете наследовать несколько интерфейсов:
class A : B, IA, IB {
// Inherits any single base class, plus multiple interfaces.
}
Но вы не можете наследовать несколько классов:
class A : B, C, IA, IB {
// Inherits multiple base classes, plus multiple interfaces.
}
Ответ 14
Это не позволяет, используйте интерфейс для его достижения.
Почему это так?
Вот ответ: это позволило компилятору сделать очень аргументированное и рациональное решение, которое всегда соответствовало бы тому, что было унаследовано и где оно было унаследовано, так что когда вы делали кастинг, и вы всегда точно знаете, какую реализацию вы имели дело с.
Ответ 15
С# не поддерживает встроенное встроенное наследование.
Для добавления множественного наследования к языкам, которые его не поддерживают, вы можете использовать шаблон двойного дизайна
Ответ 16
В качестве дополнительного предложения о том, что было предложено, другой разумный способ обеспечить функциональность, аналогичную множественному наследованию, - это реализовать несколько интерфейсов, но затем предоставить методы расширения на этих интерфейсах. Это называется mixins. Это не настоящее решение, но оно иногда обрабатывает проблемы, которые побуждают вас выполнять множественное наследование.