réutilisation de la logique d'instruction du commutateur

Question

Quelle est la meilleure façon de réutiliser la logique de commutation. J'ai cette déclaration de commutateur qui continue à apparaître dans mon code. Plutôt que de le coller coller je voudrais faire une fonction qui appelle d'autres délégués et passer ces délégués en tant que paramètres.

Ou y a-t-il un meilleur moyen?

Fonction 1:

switch (test) 
     { 
      case "x": 
       DoSomethingX(); 
       break; 
      case "y": 
       DoSomethingY(); 
       break; 
      case "z": 
       DoSomethingZ(); 
       break; 
     } 

Fonction 2:

switch (test) 
    { 
     case "x": 
      DoSomethingXxxx(); 
      break; 
     case "y": 
      DoSomethingYyyy(); 
      break; 
     case "z": 
      DoSomethingZyyy(); 
      break; 
    } 

Answer 1

Vous pouvez également avoir un dictionnaire (ou Func au lieu d'action) ou quelque chose comme ça (compte tenu de vos fonctions ont une signature similaire) . Ensuite, vous pouvez au lieu d'utiliser un interrupteur, vous pourriez avoir quelque chose comme:

public class MyClass 
{ 
    Dictionary<string, Action> myDictionary; 

    public MyClass() 
    { 
     BuildMyDictionary(); 
    } 

    private Dictionary<int, Action<int, int>> BuildMyDictionary() 
    { 
     myDictionary.Add("x", DoSomethingX); 
     myDictionary.Add("y", DoSomethingY); 
     myDictionary.Add("z", DoSomethingZ); 
     myDictionary.Add("w", DoSomethingW); 
    } 


    public void DoStuff() 
    { 
     string whatever = "x"; //Get it from wherever 
     //instead of switch 
     myDictionary[t](); 
    } 
} 

je répondu à une question similaire here un exemple similaire. En outre, essayez d'utiliser des enums plutôt que des chaînes dans votre instruction switch.

Answer 2

Voyez si vous pouvez le refactoriser en utilisant une interface et différentes implémentations de l'interface.

public interface Test { 
    void DoSomething(); 
} 

public class TestX : Test { 
    void DoSomething() { 
    } 
} 

public class TestY : Test { 
    void DoSomething() { 
    } 
} 

public class TestZ : Test { 
    void DoSomething() { 
    } 
} 


void func(Test test) { 
    test.DoSomething(); 
} 

Answer 3

Comme j'essaie de comprendre votre question, je pourrais aller à suivre:

public enum Test{ 
    X, Y, Z 
} 

/** 
* test function call 
* @a_Test - enumeration class for Test 
*/ 
public void test(Test a_Test){ 
switch(a_Test){ 
    case X: 
     x(); 
     break; 
    case Y: 
     y(); 
     break; 
    case Z: 
     z(); 
     break; 
}//switch 
}//test 

J'espère que ça aide.

Tiger