Balise de rupture à l'intérieur d'une méthode

Question

J'ai une instruction switch qui exécute une certaine logique encore et encore. Plutôt que d'utiliser couper et coller je voulais le mettre dans une fonction, mais je suis très mauvais à cela.

C'est ce que je veux faire, mais il ne compile pas parce que la balise de rupture dans la fonction n'existe pas. Quelqu'un peut-il refactoriser cela à une meilleure version de travail?

switch(param.ToString()) 
{ 
    case "1": 
    BreakIfNotArgumentType<B>(param); 
//do stuff 
    break; 
    case "2": 
    BreakIfNotArgumentType<BF>(param); 
//do stuff 
    break; 
} 

    private T BreakIfNotArgumentType<T>(object argumentObject) 
    { 
     if (argumentObject is T) 
     { 
      return (T)argumentObject; 
     } 
     else 
     { 
      break; 
     }    
    } 

Answer 1

Votre fonction reproduit essentiellement la fonctionnalité de l'opérateur as. L'opérateur as fonctionne comme un cast d'exécution-safe. Si l'instance cible ne peut pas être convertie en type cible, une référence NULL est attribuée. Pour cette raison, cela ne fonctionnera qu'avec les types de référence. L'utilisation la plus courante est la suivante ...

string bar = a as string; 

if(bar != null) 
{ 
    // do stuff 
} 

Parce que cela donne l'opération de vérification de type et de moulage en une seule instruction.

Vous devriez publier votre déclaration switch et nous pourrions être en mesure de la rationaliser mieux. Essayer d'écrire une fonction vraiment inline comme vous l'avez fait (où vous vous attendiez à ce qu'il remplace le code de la fonction dans votre instruction switch, ce qui en fait plus une macro qu'une fonction) ne fonctionnera pas.

Answer 2

Vous pourriez avoir la fonction retourne une valeur NULL si l'argument ne peut pas être jeté ou jeter une exception pour quelques idées sur la façon de gérer cette partie du code.

private T BreakIfNotArgumentType<T>(object argumentObject) 
    { 
     if (argumentObject is T) 
     { 
      return (T)argumentObject; 
     } 
     else 
     { 
      return null; 
     }    
    } 

Ou

private T BreakIfNotArgumentType<T>(object argumentObject) 
    { 
     if (argumentObject is T) 
     { 
      return (T)argumentObject; 
     } 
     else 
     { 
      throw CustomException("Argument wasn't valid!"); 
     }    
    } 

Answer 3

Faites votre méthode pour retourner un booléen et vérifier la valeur de retour:

switch(param.ToString()) 
{ 
    case "1": 
    if (CheckForArgumentType<B>(param)) 
    { 
    // Do your cast here 
    param = (B)param 
    } 
    else 
    break; 
    case "2": 
    if (CheckForArgumentType<B>(param)) 
    { 
    // Do your cast here 
    param = (B)param 
    } 
    else 
    break; 
    } 
    ................. 

    private bool CheckForArgumentType<T>(object argumentObject) 
    { 
     return (argumentObject is T) 

    } 

Answer 4

si vous avez seulement 2 valeurs à comparer avec - utiliser l'instruction IF à la place