Création qui dérive type de classe à l'exécution

Question

J'ai essayé de comprendre quelques-uns des messages de même, mais ne comprennent pas tout à fait leurs fins et je pensais que j'expliquer mon ...

J'ai une classe - entièrement défini avec le code avec les propriétés et les méthodes. De nombreuses méthodes sont virtuelles d'être surchargée par classe dérivée plus. Donc, j'ai quelque chose comme ce qui suit

Class_Main
  --  Class_A : Class_Main
  --  Class_B : Class_Main
  --  Class_C : Class_Main
  --  Class_D : Class_Main

Il me faut ensuite définir une autre classe qui peut être dynamiquement dérivée de A-D ... tels que:

Class_X : Class_A (or Class_B or Class_C or Class_D )

comme je l'ai d'autres propriétés et méthodes dans le Class_X. Étant donné que C # ne peut dériver de deux classes réelles, mais peut utiliser des interfaces, mais vous ne pouvez pas avoir le code dans une interface, à seulement signatures abstraites, comment pourrais-je le faire de cette mise en œuvre.

Merci

Answer 1

Ce que vous décrivez ressemble un peu à canard frappe . Ce n'est pas disponible en C #, car il est un statiquement typé. Peut-être quand C # 4 arrive, dynamic vous donnera ce que vous recherchez.

Si Class_X doit être « rempli » avec des fonctionnalités de ces classes, il serait commun de passer que dans la classe au moment de l'instanciation:

public class Class_X {
    private Class_Main _impl;
    public Class_X(Class_Main impl) {
        _impl = impl;
    }
}

Class_X classXA = new Class_X(new Class_A());
Class_X classXB = new Class_X(new Class_B());

À ce stade, vos instances Class_X ont accès aux propriétés et méthodes Class_Main pour toutes les classes dérivées. Cela ne fait pas Class_X un agrégat, juste vous permet d'utiliser le comportement d'exécution de toute Class_Main à l'intérieur Class_X (à travers l'objet _impl).

Answer 2

Prolonger d'une classe et comprennent l'autre classe de la classe X, et juste des méthodes d'adaptation à la carte directement à la classe à l'intérieur.

Alors, maintenant exactement C #, juste prototypage:

class ClassA {
  public void FunctionClassA(...) { ... }
  public void FunctionClassB(...) { ... }
}

class ClassX : ClassB {
  private ClassA classa;
  public ClassX() {
     classa = new ClassA();
  }
  public void FunctionClassA(...) { classa.FunctionClassA(...); }
}

Alors, ClassX a maintenant une fonction héritée (par l'apparence) de ClassA et contient toutes les méthodes de ClassB.