¿Múltiples clases abstractas derivadas?

Question

tengo que crear un sistema de gestión de cursos con las categorías de cursos:

Cooking, sewing and writing courses 

cooking y writing cada uno tiene 2 cursos (italiano, mariscos, escritura creativa y escritura de negocios). Esto crea derivada abstracta:

abstract course -> abstract cooking -> concrete seafood 

La cocción abstracto y la escritura tienen campos comunes y algunos métodos comunes, sin embargo, también tienen métodos abstractos que son resumen en la clase base.

¿Se puede hacer esto en C#? Si hago que los métodos abstractos de clase abstracta sean abstractos, Visual Studio dice que ocultan el resumen de la clase base y luego los métodos de clase concretos tienen errores que dicen que la clase base debe ser abstracta (es, pero no debe registrarse). He buscado una respuesta. Sé que la herencia individual se usa en C#, pero la herencia arrastra la cadena. ¿Cuál es la mejor respuesta?

Aquí es un fragmento de código - espero que aclara el problema:

public abstract class Course 
{ 
    public abstract void AddStudent(StudentName sn, int f); 
    public abstract decimal CalculateIncome(); 
} 

public abstract class WritingCourse : Course 
{ 
    public void AddStudent(StudentName sn, int f) 
    { 
    //Add student 
    } 
    public abstract decimal CalculateIncome(); // can only be claculated in concrete 
} 

public class BusinessWritCourse : WritingCourse 
{ 
    public void AddStudent(StudentName sn, int f): 
    base(sn, false){} 

    public decimal CalculateIncome() 
    { 
     return //do stuff 
    } 
} 

public class SewingCourse : Course 
{ 
    public override void AddStudent(StudentName sn, int f) 
    { 
     //do stuff 
    } 

    public override decimal CalculateIncome() 
    { 
     return //do stuff 
    } 
} 

Answer 1

Si he entendido bien creo que te gustaría utilizar la palabra clave 'virtual' en los métodos abstractos que desea anular?

Si estamos hablando del error que dice algo así como "algún método oculta miembro heredado, añadir la nueva palabra clave si ocultando estaba destinado", entonces virtual en el método de base y anular en el método de heredar hará:

public abstract class BaseClass 
{ 
    public virtual void SomeMethod() 
    { 
    } 
} 


public abstract class InheritingClass : BaseClass 
{ 
    public override void SomeMethod() 
    { 
    } 
} 

Answer 2

si hago la clase abstracta derivada métodos abstracta Visual Studio dice que ocultar la clase base abstracta y continuación, los métodos de la clase de hormigón tienen errores diciendo la clase base debe ser resumen (que es, pero no debe registrarse)

Si tiene la clase base 'A' que tiene un método abstracto 'b()', entonces no tiene que declarar 'b()' de nuevo como abstracto en B: A, para tener C: B anularlo, simplemente no lo use. Incluso si se ha sobrepasado la 'b()' método en la clase B puede volver a anular en clase 'c()' (e incluso el uso de base(); para ejecutar la aplicación de B

Algunos código:.

.

public abstract class A{ 
    public abstract void b(); 
} 

public class B : A{ 
    public override void b() { //do stuff }; //overrides b from a 
    public virtual void c() { //do stuff }; //creates an implemented method c in B that can be overriden by childs. 
    public void d() { //do stuff}; 
} 

public class C : B{ 
    public override void b() { //do stuff}; //overrides b from A, works! 
    public override void c() {//do stuff}; //overrides c from B, works! 
    public override void d() {//do stuff}; //doesn't work since d from B isn't abstract or virtual (hides it) 
    public new void d() {//do stuff}; //works, hides d, but when you use inheritance this method will not be called, instead B's d() method will be called, only if you see C as the specific class C this will work 
} 

También para aclarar: los métodos declarados abstractos deben ser reemplazados (como en una interfaz, y solo por el hijo directo de la clase que declara el método abstracto). Los métodos declarados virtuales pueden ser anulados, pero no tienen que ser

Answer 3

Creo que este tipo de problemas es mejor resolver usando interfaces y no clases abstractas: Ej:

// 
interface IInterface1 
{ 
    void SameMethod(); 
} 

interface IInterface2 
{ 
    void SameMethod(); 
} 


class TestClass : IInterface1, IInterface2 
{ 
    void IInterface1.SameMethod() 
    { 
     // do one thing for Interface 1 
    } 

    void IInterface2.SameMethod() 
    { 
     // do something elsefor Interface 2 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     TestClass test = new TestClass(); 

     IInterface1 i1 = test; 
     i1.SameMethod(); // will call IInterface1.SameMethod() 

     IInterface2 i2 = test; 
     i2.SameMethod(); // will call IInterface2.SameMethod() 

    } 
} 

Answer 4

public class StudentName 
{ } 

public abstract class Course 
{ 
    public abstract void AddStudent(StudentName sn, int f); 
    public abstract decimal CalculateIncome(); 
} 

public abstract class WritingCourse : Course 
{ 
    override public void AddStudent(StudentName sn, int f) 
    { 
     //Add student 
    } 
    override public abstract decimal CalculateIncome(); // can only be claculated in concrete 
} 

public class BusinessWritCourse : WritingCourse 
{ 
    override public void AddStudent(StudentName sn, int f) 
    { base.AddStudent(sn, 0); } 

    override public decimal CalculateIncome() 
    { 
     return (decimal)3.4;//do stuff 
    } 
} 

public class SewingCourse : Course 
{ 
    public override void AddStudent(StudentName sn, int f) 
    { 
     //do stuff 
    } 

    public override decimal CalculateIncome() 
    { 
     return (decimal)10; //do stuff 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 

    } 
}