"héritage" pour remplacer une fonction

Question

Dans une certaine mesure, il s'agit plus d'un exercice de réflexion que d'un réel problème, car je n'ai pas assez de classes CustomFS pour être particulièrement dérangé par l'utilisation de copier coller. Mais je me demande s'il y a un meilleur moyen.

Supposons que j'ai plusieurs classes CustomFS, CustomFS2, etc., tous héritant de FS, FS2, etc. FS/FS2/etc. tous héritent de FSG, qui a une fonction GetStuff. En supposant que je n'ai pas la possibilité de modifier FS et FSG comment puis-je remplacer une fonction particulière dans la plupart des FS/FS2 avec une seule classe CustomFS, et sans construire CustomFS avec FS et ajouter une fonction wrapper pour toutes les méthodes de FS à customFS.

stratégie actuelle: Copier/coller:

class CustomFS : FS 
{ 
    protected override int GetStuff(int x) 
    { 
     int retval = base.GetStuff(x); 
     return retval + 1; 
    } 
} 

class CustomFS2 : FS2 
{ 
    protected override int GetStuff(int x) 
    { 
     int retval = base.GetStuff(x); 
     return retval + 1; 
    } 
} 

Answer 1

Vous ne pouvez pas, sauf au moyen d'une procuration ou en émettant vos propres classes dérivées via Reflection.Emit. Cependant, si vous avez des fonctionnalités plus complexes que vous devez effectuer sur chaque classe, vous pouvez créer une méthode d'assistance (probablement générique et statique) qui effectue le travail réel.

Answer 2

Si je comprends bien votre question, cela semble être un bon moyen pour le modèle de conception de stratégie: http://www.dofactory.com/patterns/patternstrategy.aspx

Cela ferait probablement de sens que si votre fonction de priorité est plus complexe que quelques lignes. Mais, au fond, vous pourriez avoir une classe StuffGetter aurait sa propre méthode GetStuff:

public class StuffGetter 
{ 
    public int GetStuff(int rawStuff) 
    { 
     return rawStuff + 1 // presumably, the real example is more complicated than this 
    } 
} 

Ensuite, vous feriez quelque chose comme ceci:

class CustomFS : FS 
{ 
    private StuffGetter _stuffGetter { get; set; } 

    public CustomFS(StuffGetter stuffGetter) 
    { 
     _stuffGetter = stuffGetter; 
    } 

    protected override int GetStuff(int x) 
    { 
     int retval = base.GetStuff(x); 
     return _stuffGetter.GetStuff(retval); 
    } 
} 

class CustomFS2 : FS2 
{ 
    private StuffGetter _stuffGetter { get; set; } 

    public CustomFS2(StuffGetter stuffGetter) 
    { 
     _stuffGetter = stuffGetter; 
    } 

    protected override int GetStuff(int x) 
    { 
     int retval = base.GetStuff(x); 
     return _stuffGetter.GetStuff(retval); 
    } 
} 

Fondamentalement, vous passez dans une StuffGetter instance vers classe qui a besoin de votre implémentation personnalisée GetStuff. Comme alternative, vous pouvez rendre StuffGetter une classe statique (ce qui vous éviterait de devoir passer dans une instance), mais cela est moins flexible. Par exemple, si vous souhaitez deux implémentations différentes en fonction de la situation, en utilisant des instances, vous pouvez simplement passer (et stocker) une instance contenant l'implémentation souhaitée.

Answer 3

class CustomFS : FS 
{ 
    protected override int GetStuff(int x) 
    { 
     return CustomHelper.GetStuff(base.GetStuff(x)); 
    } 
} 

class CustomFS2 : FS2 
{ 
    protected override int GetStuff(int x) 
    { 
     return CustomHelper.GetStuff(base.GetStuff(x)); 
    } 
} 

static class CustomHelper 
{ 
    static int GetStuff(int x) 
    { 
     return x + 1; 
    } 
}