¿C # admite herencia múltiple?

Un colega y yo estamos teniendo un poco de discusión sobre la herencia múltiple. Estoy diciendo que no es compatible y él dice que sí. Entonces, pensé que podría preguntarle al grupo inteligente en la red.

¡No, usa interfaces en su lugar! ^. ^

Lo sentimos, no puedes heredar de multiple classes . Puede usar interfaces o una combinación de one class and interface(s) , donde la (s) interfaz (es) debe (n) seguir el nombre de la clase en la firma.

 interface A { } interface B { } class Base { } class AnotherClass { } 

Posibles formas de heredar:

 class SomeClass : A, B { } // from multiple Interface(s) class SomeClass : Base, B { } // from one Class and Interface(s) 

Esto no es legal

 class SomeClass : Base, AnotherClass { } 

C # 3.5 o inferior no es compatible con la herencia múltiple, pero C # 4.0 podría hacerlo utilizando, como lo recordaba, Dynamics.

La herencia múltiple no es compatible con C #.

Pero si desea “heredar” el comportamiento de dos fonts, ¿por qué no usar el combo?

  • Composición

    y

  • Inyección de dependencia

Existe un principio de OOP básico pero importante que dice: “Favorecer la composición sobre la herencia”.

Puedes crear una clase como esta:

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

Como puede ver, las dependencias (implementaciones reales de las interfaces) se inyectan a través del constructor. Tu clase no sabe cómo se implementa cada clase, pero sabe cómo usarlas. De ahí un acoplamiento débil entre las clases implicadas aquí pero el mismo poder de uso.

Las tendencias de hoy muestran que la herencia está “pasada de moda”.

No puedes hacer herencia múltiple en C # hasta 3.5. No sé cómo funciona en 4.0 ya que no lo he visto, pero @tbischel ha publicado un enlace que necesito leer.

C # le permite hacer “implementaciones múltiples” a través de interfaces, que es bastante diferente de “herencia múltiple”

Entonces, no puedes hacer:

 class A{} class B{} class C : A, B{} 

Pero, puedes hacer:

 interface IA{} interface IB{} class C : IA, IB{} 

HTH

Al igual que Java (que es de lo que C # se deriva indirectamente), C # no admite múltiples inhertance.

Lo que quiere decir que los datos de clase (variables de miembro y propiedades) solo se pueden heredar de una única clase base principal. El comportamiento de clase (métodos miembro), por otro lado, se puede heredar de múltiples interfaces base padre.

Algunos expertos, especialmente Bertrand Meyer (considerado por algunos como uno de los padres de la progtwigción orientada a objetos), piensan que esto descalifica a C # (y Java, y todo lo demás) de ser un lenguaje “verdadero” orientado a objetos.

En realidad, depende de tu definición de herencia:

  • puede heredar la implementación (miembros, es decir, datos y comportamiento) de una única clase, pero
  • usted puede heredar interfaces de múltiples , bueno, interfaces.

Esto no es lo que generalmente se entiende por el término “herencia”, pero tampoco es completamente irrazonable definirlo de esta manera.

C # no admite la herencia múltiple de clases, pero se le permite heredar / implementar cualquier cantidad de interfaces.

Esto es ilegal (B, C, D y E son todas las clases)

 class A : B, C, D, E { } 

Esto es legal (IB, IC, ID e IE son todas las interfaces)

 class A : IB, IC, ID, IE { } 

Esto es legal (B es una clase, IC, ID e IE son interfaces)

 class A : B, IC, ID, IE { } 

La composición sobre la herencia es un patrón de diseño que parece ser favorable incluso en idiomas que admiten herencia múltiple.

Es posible que desee llevar su argumento un paso más allá y hablar sobre los patrones de diseño, y puede averiguar por qué querría molestarse en intentar heredar de varias clases en c # si pudiera

Patrón de herencia múltiple simulado
http://www.codeproject.com/KB/architecture/smip.aspx enter image description here

La herencia múltiple permite a los progtwigdores crear clases que combinan aspectos de múltiples clases y sus correspondientes jerarquías. Por ej. C ++ te permite heredar de más de una clase

En C #, las clases solo pueden heredar de una única clase principal, que se denomina herencia única. Pero puede usar interfaces o una combinación de una clase e interfaz (s), donde la (s) interfaz (es) debe (n) seguir el nombre de la clase en la firma.

Ex:

 Class FirstClass { } Class SecondClass { } interface X { } interface Y { } 

Puedes heredar de la siguiente manera:

clase NewClass: X, Y {} En el código anterior, la clase “NewClass” se crea a partir de múltiples interfaces.

clase NewClass: FirstClass, X {} En el código anterior, la clase “NewClass” se crea a partir de la interfaz X y la clase “FirstClass”.

No puedes heredar múltiples clases a la vez. Pero hay una opción para hacer eso con la ayuda de la interfaz. Vea el código a continuación

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

puedes llamarlos de la siguiente manera

 AB ab = new AB(); ab.PrintIA(); ab.PrintIB(); 

No lo permite, use la interfaz para lograrlo.

¿Por qué es así?

Aquí está la respuesta: se le permitió al comstackdor tomar una decisión muy razonada y racional que siempre fue consistente con respecto a lo que se hereda y de dónde se hereda, de modo que cuando lo hizo y siempre sabe exactamente con qué implementación estaba tratando. .

En general, no puedes hacerlo.

Considere estas interfaces y clases:

 public class A { } public class B { } public class C { } public interface IA { } public interface IB { } 

Puedes heredar múltiples interfaces:

 class A : B, IA, IB { // Inherits any single base class, plus multiple interfaces. } 

Pero no puedes heredar múltiples clases :

 class A : B, C, IA, IB { // Inherits multiple base classes, plus multiple interfaces. } 

C # no admite herencia múltiple integrada.

Para agregar herencia múltiple a idiomas que no lo admiten, puede usar el patrón de diseño gemelo

Como una sugerencia adicional a lo que se ha sugerido, otra forma ingeniosa de proporcionar una funcionalidad similar a la herencia múltiple es implementar múltiples interfaces PERO luego proporcionar métodos de extensión en estas interfaces. Esto se llama mixins . No es una solución real, pero a veces maneja los problemas que lo llevarían a querer realizar una herencia múltiple.