Fonction d'exécution basée sur des données dans une table de recherche

Question

Je souhaite appeler une méthode basée sur une valeur dans une table de recherche. Les valeurs seront recherchées dans une base de données et seront itérées à travers. Ce que je suis en train d'éviter est la suivante:

foreach (Row r in rows) 
{ 
    if (r["command"] == "Command1") 
     MyClass.Command1(); 
    else if (r["command"] == "Comman2") 
     MyClass.Command2(); 
    else if (r["command"] == "Comman3") 
     MyClass.Command3(); 
} 

Ce code est l'héritage que je dois soutenir, mais je sais qu'il ya sûrement une meilleure façon de le faire. Actuellement, le code ressemble à ce qui précède mais je cherche une solution plus élégante.

EDIT:

Sur la base des suggestions ci-dessous, je suis en train de faire quelque chose comme ceci:

static void Main(string[] args) 
    { 

     Dictionary<string, Action<MyClass>> myActions = new Dictionary<string,Action<MyClass>>(); 
     myActions.Add("Command1",MyClass.DoCommand1("message1")); 
     myActions.Add("Command2",MyClass.DoCommand1("message2")); 

     myActions["Command1"](); 

    } 

avec mon fichier de classe qui ressemble à ceci:

public class MyClass 
{ 
    public void DoCommand1(string message) 
    { 
     Console.WriteLine(message); 
    } 

    public void DoCommand2(string message) 
    { 
     Console.WriteLine(message); 
    } 
} 

Cependant, je Je reçois des erreurs de syntaxe indiquant qu'une référence d'objet est requise pour le fichier, la méthode ou la propriété non statique MyClass.DoCommand1 (chaîne). Des idées?

Veuillez noter que j'utilise le framework .NET 2.0.

Answer 1

Vous pouvez utiliser la réflexion:

string command = (string)r["command"]; 
typeof(MyClass) 
    .GetMethod(command, BindingFlags.Static | BindingFlags.Public) 
    .Invoke (null, null); 

Ou vous pouvez également utiliser les délégués:

var actionMap = new Dictionary<string, Action<string>> { 
    {"SomeAction", MyClass.SomeAction}, 
    {"SomeAction2", MyClass.SomeAction2}, 
    {"SomeAction3", MyClass.SomeAction3}, 
}; 
actionMap[r["command"]]("SomeString"); 

Avec les délégués, vous obtenez une syntaxe agréable et d'éviter la perte de performance de la réflexion.

MISE À JOUR: J'ai remarqué que vous utilisez .NET 2.0, vous devez faire:

class Program 
{ 
    delegate void PoorManAction (string param); 
    static void Main(string[] args) 
    { 

     Dictionary<string, PoorManAction> actionMap = new Dictionary<string, PoorManAction>(); 
     actionMap.Add("SomeMethod1", MyClass.SomeMethod1); 
     actionMap.Add("SomeMethod2", MyClass.SomeMethod2); 
     actionMap.Add("SomeMethod3", MyClass.SomeMethod3); 
     actionMap.Add("SomeMethod4", MyClass.SomeMethod4); 
     actionMap[r["command"]]("SomeString"); 

    } 
} 

MISE À JOUR 2:: Maintenant, l'exemple utilise des méthodes avec un paramètre de chaîne comme on le voit dans la question mise à jour

Answer 2

Vous pouvez utiliser la réflexion pour appeler la méthode.

typeof (MyClass) 
    .GetMethod((string)r["command"], BindingFlags.Static | BindingFlags.Public) 
    .Invoke(null, null); 

Answer 3

Vous pouvez utiliser la réflexion pour appeler dynamiquement la méthode. Ce ne serait probablement pas aussi efficace qu'une instruction switch à cause de la surcharge de l'utilisation de la réflexion.

Answer 4

Vous devez utiliser les délégués anonymes pour produire un délégué sur une méthode avec certains (ou tous) des arguments liés à des valeurs spécifiques:

static void Main(string[] args) 
{ 
    Dictionary<string, Action<MyClass>> myActions = 
     new Dictionary<string,Action<MyClass>>(); 

    myActions.Add("Command1", 
     delegate { MyClass.DoCommand1("message1"); }); 
    myActions.Add("Command2", 
     delegate { MyClass.DoCommand1("message2"); }); 

    myActions["Command1"](); 

}