Comment appeler une méthode de sous-classe sur un objet baseclass?

Question

J'utilise une bibliothèque qui génère un tas de classes pour moi.

Ces classes héritent toutes d'une classe de base commune, mais cette classe de base ne définit pas de méthodes communes à toutes les sous-classes.

Par exemple:

SubClassA : BaseClass{ 
    void Add(ItemA item) {...} 
    ItemA CreateNewItem() {...} 
} 

SubClassB: BaseClass{ 
    void Add(ItemB item) {...} 
    ItemB CreateNewItem() {...} 
} 

Malheureusement, la classe de base n'a pas ces méthodes. Ce serait formidable:

BaseClass{ 
    // these aren't actually here, I'm just showing what's missing: 
    abstract void Add(ItemBaseClass item); // not present! 
    abstract ItemBaseClass CreateNewItem(); // not present! 
} 

Comme il existe une classe de base commune pour mes objets A + B et une classe de base commune pour les objets Item, je l'avais espéré profiter du merveilleux monde du polymorphisme.

Malheureusement, comme les méthodes communes ne sont pas réellement présentes dans la classe de base, je ne peux pas les appeler virtuellement. par exemple, ce serait parfait:

BaseClass Obj; 
Obj = GetWorkUnit(); // could be SubClassA or SubClassB 

ItemBaseClass Item = Obj.CreateNewItem(); // Compile Fail: CreateNewItem() isn't in the base class 

Item.DoSomething(); 

Obj.Add(Item); // Compile Fail: Add(...) isn't in the base class 

coulée De toute évidence fonctionnerait, mais je aurais besoin de savoir quel type j'avais qui annulerait les avantages. Comment puis-je "forcer" un appel à ces méthodes? Je ne m'inquiète pas d'obtenir un objet qui n'applique pas la méthode que j'essaie d'appeler. Je peux réellement faire ce que je veux en VB - je ne suis pas IntelliSense, mais est content et il fonctionne le compilateur:

CType(Obj, Object).Add(Item) // Note: I'm using C#--NOT VB 

againt, je n'ai pas le contrôle de ces classes (que je pense que les règles sur les classes partielles) .

Answer 1

Vous ne pouvez pas appeler une méthode non virtuelle d'une classe dérivée sans recourir à la réflexion ou à d'autres astuces sales. Si vous voulez le faire, il est facile alors:

// obj is your object reference. 
obj.GetType().InvokeMember("MethodName", 
    System.Reflection.BindingFlags.InvokeMethod, null, obj, null /* args */) 

Answer 2

Déclare eux virtuel:

http://msdn.microsoft.com/en-us/library/9fkccyh4(VS.71).aspx

Answer 3

je pourrais manquer quelque chose, mais pourquoi ne pas faire et d'hériter d'une interface avec ces méthodes ? Si vous contrôlez le processus de création des instances, vous pouvez obtenir ce que vous voulez en héritant des classes que vous n'avez pas écrites et en ajoutant ensuite interface (aucun code à écrire, le compilateur mappe l'interface avec les méthodes non virtuelles existantes).

Answer 4

Si vous utilisez Visual Studio 2008, vous pouvez créer une méthode d'extension pour la classe de base. À l'intérieur de cette méthode d'extension, vous feriez le cast et appelez la méthode de la sous-classe. Cela devrait fonctionner pour 2.0 cadre des projets ciblés et, aussi longtemps que vous compilez à partir withing VS 2008. Emprunter l'autre code de réflexion proposé, vous pouvez effectuer les opérations suivantes ...

public static class MyExtensions 
{ 
    public static ItemBaseClass CreateNewItem(this BaseClass item) 
    { 
     return item.GetType().InvokeMember("MethodName", System.Reflection.BindingFlags.InvokeMethod, null, obj, null /* args */); 
    } 
} 

Answer 5

Une autre possibilité est d'utiliser un mécanisme de proxy, comme un RealProxy (pas très efficace en termes de performance) ou mieux en utilisant dynamiquement DynamicMethods créé de sorte que le surcoût d'utiliser la réflexion est seulement là une fois par type à soutenir, tout en le gardant aussi flexible que la méthode de réflexion . C'est payant lorsque vous devez appeler la méthode plusieurs fois, mais cela nécessite des connaissances de MSIL.

Answer 6

Vous avez oublié le mot clé "override" dans les définitions de méthodes de vos sous-classes. Quand quelque chose est déclaré "abstrait", il est par définition virtuel, et donc dans la sous-classe, vous devez mettre le mot-clé "override" devant la déclaration de la méthode. Donc, ce qui devrait fonctionner est ci-dessous:

BaseClass{ 
    abstract void Add(ItemBaseClass item); // not present! 
    abstract ItemBaseClass CreateNewItem(); // not present! 
} 

SubClassA : BaseClass{ 
    override void Add(ItemA item) {...} 
    override ItemA CreateNewItem() {...} 
} 

SubClassB: BaseClass{ 
    override void Add(ItemB item) {...} 
    override ItemB CreateNewItem() {...} 
} 

Cela devrait fonctionner exactement comme vous le souhaitez dans votre exemple d'utilisation.

Answer 7

Problème n ° 1: vos sous-classes ne prévalent pas quoi que ce soit Problème # 2: vos sous-classes ont des signatures de fonction que votre classe de base

Assurez-vous que vos signatures sont correctes, et si vous les remplaçant, marque les virtuelles et non abstraites. Vous devrez ajouter un corps vide aux fonctions virtuelles de la classe de base si vous ne voulez pas qu'elles fassent quoi que ce soit.

class ItemBase{} 

class ItemA : ItemBase{} 

class ItemB : ItemBase{} 

class BaseClass 
{ 
    public virtual void Add(ItemBase item){} 
    public virtual ItemBase CreateItem() { return null; } 
} 

class ClassA : BaseClass 
{ 
    public override void Add(ItemBase item) 
    { 
     //do whatever 
     throw new NotImplementedException(); 
    } 

    public ItemBase CreateItem() 
    { 
     //create an ItemBase and return 
     throw new NotImplementedException(); 
    } 
}