Comment définissez-vous une méthode dans une classe dans son instance?

Question

C'est probablement très facile, mais je suis perplexe. Je voudrais créer une classe à usage général qui sera utilisée plusieurs fois dans mon programme. Je veux que ce soit très léger et super rapide.

Pour un exemple très simple en C#:

public class SystemTest 
{ 
    public TestMethod(string testString) 
    { 
     if(testString == "blue") 
     { 
     RunA(); 
     } 
     else if(testString == "red") 
     { 
     RunB(); 
     } 
     else if(testString == "orange") 
     { 
     RunA(); 
     } 
     else if(testString == "pink") 
     { 
     RunB(); 
     } 
    } 

    protected void RunA() {} 
    protected void RunB() {}  
} 

Je veux que le Runa() et le RunB() à définir et contrôlé par l'objet instanciation cette classe. Il appartiendra complètement à l'objet d'instancer la classe SystemTest pour comprendre ce que feront RunA() et RunB(). Comment est-ce que tu fais ça?

Je ne veux pas que l'objet d'instance hérite toujours de cette classe SystemTest, et je voudrais qu'elle s'exécute très rapidement. Les seules choses auxquelles je pense sont des choses complexes et exigeantes en matière de processeur. Je sais qu'il existe un moyen plus simple de le faire.

---

Edit: En règle générale, ce qui est plus rapide, le délégué ou la méthode d'interface sur les réponses ci-dessous?

Answer 1

On dirait que vous voulez une interface, comme:

interface ITestable { 
    void RunA(); 
    void RunB(); 
} 

et vous passez que (soit au SystemTest cteur, ou TestMethod). Les classes appelantes pourraient (par exemple) implémenter ITestable et appeler TestMethod (this, someString).

Alternativement, peut-être une méthode d'extension? btw, l'argument string pourrait peut-être être une énumération?

public interface ITestable { 
    void RunA(); 
    void RunB(); 
} 
public static class SystemTest 
{ 
    public static void TestMethod(this ITestable item, string testString) 
    { 
     if(testString == "blue") 
     { 
     item.RunA(); 
     } 
     else if(testString == "red") 
     { 
      item.RunB(); 
     } 
     else if(testString == "orange") 
     { 
      item.RunA(); 
     } 
     else if(testString == "pink") 
     { 
      item.RunB(); 
     } 
    } 
} 

Ensuite, les appelants simplement mettre en œuvre ITestable, et tout le monde peut appeler foo.SomeMethod(color); pour une instance foo.

Answer 2

Vous pouvez:

public class SystemTest 
{ 
    Action RunA; 
    Action RunB; 
    public SystemTest(Action a, Action b) 
    { 
     RunA = a; 
     RunB = b; 
    } 
    //rest of the class 
} 

Answer 3

S'il n'y a que des options de couleurs limitées comme le bleu, rouge, orange et rose. Vous pouvez créer un ENUM comme

public enum Color 
{ 
    Blue, 
    Red, 
    Orange, 
    Pink 
} 

Et utiliser cette ENUM une déclaration switch avec l'une des solutions mentionner ici. Le compilateur traite enums comme des entiers & puisque vous voulez des performances. La comparaison d'entier est plus efficace que les comparaisons de chaînes.

switch (color) 
{ 
case Color.Blue: 
case Color.Orange: 
        RunA(); 
        break; 
case Color.Red: 
case Color.Pink: RunB(); 
        break; 
} 

Answer 4

Une autre option non mentionné est en train de changer pour être des événements au lieu de méthodes Runa et RunB. Les événements dans .net sont raisonnablement légers et rapides, et correspondraient potentiellement à votre modèle d'utilisation sans nécessiter la construction d'une nouvelle classe pour définir le comportement de chaque instance/utilisation. Étant donné que vous voulez un comportement basé sur instanciation, vous devrez retravailler ceci pour utiliser des délégués ou des événements, ou pour passer dans une seule classe de base ou une interface et appeler des méthodes directement sur cela.

Answer 5

Exposez les méthodes RunA, RunB en tant qu'événements afin que tout appelant puisse s'y attacher. Ex .:

public class SystemTest 
{ 
    public TestMethod(string testString) 
    { 
     if(testString == "blue") 
     { 
     RunA(); 
     } 
     else if(testString == "red") 
     { 
     RunB(); 
     } 
     else if(testString == "orange") 
     { 
     RunA(); 
     } 
     else if(testString == "pink") 
     { 
     RunB(); 
     } 
    } 

    protected event Action RunA; 
    protected event Action RunB;  
} 

Answer 6

Pourquoi utiliser une classe quand tout ce dont vous avez besoin est une structure de données?

Dictionary<string, Action> MethodMap = new Dictionary<string, Action> 
{ 
    { "red", RedMethod }, 
    { "blue", BlueMethod }, 
    { "green", GreenMethod }, 
    { "yellow", YellowMethod } 
}; 

Ensuite, vous n'avez pas besoin d'une classe pour exécuter la méthode; simplement

Method[key]; 

fera l'affaire.