Est-il une différence significative entre l'utilisation de if/else et switch-case en C#?

En général (en tenant compte de toutes les langues et tous les compilateurs) une instruction switch PEUT PARFOIS être plus efficace que d'un if /else, car il est facile pour un compilateur pour générer sauter les tables à partir d'instructions de commutation. Il est possible de faire la même chose pour les if /else, compte tenu des contraintes appropriées, mais qui est beaucoup plus difficile.

Dans le cas de C#, c'est vrai aussi, mais pour d'autres raisons.

Avec un grand nombre de chaînes de caractères, il existe un important avantage de performance à l'aide d'une instruction switch, parce que le compilateur va utiliser une table de hachage pour mettre en œuvre le saut.

Avec un petit nombre de chaînes de caractères, les performances entre les deux est le même.

C'est parce que dans ce cas, le compilateur C# ne pas générer un saut de la table. Au lieu de cela, il génère MSIL qui est équivalent à if /ELSE blocs.

Il y a un "switch" instruction MSIL que lorsque jitted va utiliser un saut de la table pour mettre en œuvre une instruction switch. Il fonctionne uniquement avec les types integer, toutefois, cette question porte sur les chaînes de caractères).

Pour un petit nombre de chaînes, il est plus efficace pour le compilateur pour générer des SI /d'AUTRE blocs, puis il consiste à utiliser une table de hachage.

Quand j'ai d'abord remarqué, j'ai fait l'hypothèse que, parce que SI /d'AUTRE des blocs ont été utilisés avec un petit nombre de chaînes, que le compilateur n'a la même transformation pour un grand nombre de chaînes.

C'était FAUX. 'IMA' a eu la gentillesse de le signaler à moi (bien...il n'était pas du genre à ce sujet, mais il avait raison et j'avais tort, ce qui est le plus important)

J'ai aussi fait un abruti hypothèse sur l'absence d'un "switch" de l'enseignement en MSIL (j'ai pensé, si il y avait un interrupteur primitive, pourquoi n'ont-ils pas de l'utiliser avec une table de hachage, donc il ne doit pas être un interrupteur de primitives.... ). C'était à la fois tort et incroyablement stupide de ma part. Une fois de plus 'IMA' l'a souligné à moi.

J'ai fait les mises à jour ici parce que c'est la cote la plus élevée de poste, et l'on a accepté la réponse.

Cependant,je l'ai fait Wiki de la Communauté parce que je me dis que je ne mérite pas la REP pour le mal. Si vous obtenez une chance, veuillez jusqu'vote "ima"s post.

Le compilateur va optimiser un peu tout dans le même code avec des différences mineures (Knuth, anyone?).

La différence est que l'instruction switch est plus propre que quinze si else qui s'enchaînent.

Amis ne laissez pas les amis de la pile if-else.

Je n'avais pas voir quelqu'un d'autre soulèvent la (évident, non?) point que la prétendue efficacité de l'avantage de l'instruction switch est en fonction des différents cas d'environ la même probabilité. Dans les cas où un (ou quelques) les valeurs sont beaucoup plus probablement, le si-alors-sinon échelle peut être beaucoup plus rapide, en assurant les cas les plus courants sont d'abord vérifié:

Ainsi, par exemple:

if (x==0) then {
  //do one thing
} else if (x==1) {
  //do the other thing
} else if (x==2) {
  //do the third thing
}

vs

switch(x) {
  case 0: 
         //do one thing
         break;
  case 1: 
         //do the other thing
         break;
  case 2: 
         //do the third thing
         break;
}

Si x est égal à zéro à 90% du temps, le "if-else" code peut être deux fois plus rapide que le commutateur de code. Même si le compilateur transforme le "switch" dans une sorte d'astuce de la table-driven goto, il persiste à ne pas être aussi rapide qu'une simple vérification de zéro.

Côté sujet, mais je m'inquiète souvent (et plus souvent) if/else et switch déclaration à obtenir de façon trop grande avec de trop nombreux cas. Ceux-ci sont souvent mal maintenabilité.

Les coupables les plus communs comprennent:

1. D'en faire trop à l'intérieur de plusieurs instructions if
2. Plus de cas des déclarations qu'il est humainement possible d'analyser
3. Trop grand nombre de conditions dans le cas de l'évaluation pour savoir ce qu'on cherche

À corriger:

1. Extrait de la Méthode de refactoring.
2. Utiliser un Dictionnaire avec la méthode des pointeurs au lieu d'un cas, ou de l'utilisation du Cio pour l'ajout de configurabilité. Méthode usines peuvent également être utiles.
3. Extrait les conditions de leur propre méthode

Ce n'est pas réellement répondre à votre question, mais étant donné, il y aura peu de différence entre les versions compilées, je vous invite à écrire votre code dans une manière qui correspond le mieux à vos intentions. Non seulement il y a une meilleure chance de le compilateur fait ce que vous attendez, mais il sera plus facile pour les autres de maintenir votre code.

Si votre intention est de direction de votre programme basé sur la valeur d'une variable ou d'un attribut, puis une instruction switch représente le mieux cette intention.

Si votre intention est de direction de votre programme en fonction de différentes variables/attributs/des conditions, puis un if/else si la chaîne correspond le mieux à cette intention.

Je le ferai que cody est juste sur les gens oublient la commande break, mais presque aussi souvent que je vois des gens faire compliqué si les blocs où ils obtiennent la { } de mal, donc, les lignes qui doivent être dans l'instruction conditionnelle ne le sont pas. C'est l'une des raisons pour lesquelles je toujours inclure { } sur mon si les déclarations, même si il ya une ligne. Non seulement est-il plus facile à lire, mais si j'ai besoin d'ajouter une autre ligne au conditionnel, je ne peux pas oublier de l'ajouter.

Que par ce lien, SI vs Commutateur comparaison de l'itération de test à l'aide de l'interrupteur et si la déclaration, c'est comme pour les 1 000 000 000 d'itérations, le Temps pris par Commutateur Instruction=43.0 s & par Si l'Instruction = 48.0 s

Qui est littéralement 20833333 itérations par seconde, Donc, Doit-on vraiment besoin de se concentrer plus,

P. S:Juste pour savoir la différence de performances pour les petites liste de conditions.

Intérêt de la question. Il en a été question il y a quelques semaines au travail et nous avons trouvé une réponse par écrit un exemple extrait de code et en le regardant dans .NET Réflecteur (réflecteur est génial!! je l'aime).

C'est ce que nous avons découvert:
Valide instruction switch pour autre chose qu'une chaîne est compilé pour IL comme une instruction switch. Toutefois, SI c'est une chaîne, il est réécrit comme un if/else if/else dans IL. Dans notre cas, nous voulions savoir comment les instructions de commutation de comparer les chaînes d'e.g est sensible à la casse etc. et réflecteur rapidement nous a donné une réponse. C'était utile de le savoir.

Si vous voulez faire de la casse de comparer des chaînes de caractères, alors vous pourrait d'une instruction switch car il est plus rapide que l'exécution d'une Chaîne de caractères.Comparer dans un if/else. (Edit: Lire Ce qui est plus rapide, basculer sur la chaîne ou elseif sur type? pour quelques tests de performance) Cependant, si vous vouliez faire un casse, alors il est préférable d'utiliser un si/d'autre que le code résultant est pas assez.

switch (myString.ToLower())
{
  //not a good solution
}

La meilleure règle à suivre est d'utiliser les instructions switch si elle a un sens (sérieusement), e.g:

• il améliore la lisibilité de votre code
• vous comparez une plage de valeurs (float, int) ou un enum

Si vous avez besoin de manipuler la valeur à introduire dans l'instruction switch (créer une variable temporaire pour basculer contre), alors vous devriez probablement être l'aide d'un if/else contrôle de l'instruction.

Une mise à jour:

Il est effectivement préférable de convertir la chaîne en majuscules (par exemple,ToUpper()) comme cela a été apparemment il y a d'autres optimisations que le juste-à-temps compilateur peut le faire comme lorsque comparé à la ToLower(). C'est un micro-optimisation, cependant dans une boucle serrée, il pourrait être utile.

---

Une petite note à part:

Pour améliorer la lisibilité des instructions de commutation essayez ce qui suit:

• mettre le plus probable de la branche de la première c'est à dire les plus accessibles
• si elles sont toutes susceptibles de se produire, en dresser la liste dans l'ordre alphabétique, de sorte qu'il est plus facile de le trouver.
• ne jamais utiliser la valeur par défaut fourre-tout pour la dernière condition, qui est paresseux et entraîner des problèmes plus tard dans le code de la vie.
• utiliser la valeur par défaut fourre-tout pour affirmer un état inconnu, même si il est très peu probable que cela se produira jamais. c'est ce qu'affirme sont bons pour.

Quelque chose que je viens de remarquer, c'est que vous pouvez combiner les if/else et switch états! Très utile lorsqu'il est nécessaire de vérifier les conditions préalables.

if (string.IsNullOrEmpty(line))
{
    //skip empty lines
}
else switch (line.Substring(0,1))
{
    case "1":
        Console.WriteLine(line);
        break;
    case "9":
        Console.WriteLine(line);
        break;
    default:
        break;
}

une instruction switch bref c'est une comparaison pour l'égalité. l'événement de clavier ont un grand avantage sur instruction de commutation est alors facile à lire et à écrire du code, puis d'un if elseif instruction, manque un {crochet} peut obtenir troublant ainsi.

char abc;
switch(abc)
{
case a: break;
case b: break;
case c: break;
case d: break;
}

Un si elseif déclaration est idéal pour plus, alors une solution si(theAmountOfApples est supérieure à 5 && theAmountOfApples est à moins de 10) enregistrez vos pommes
else if(theAmountOfApples est supérieure à 10 || theAmountOfApples == 100) de vendre vos pommes. Je n'ai pas l'écrire en c# ou c++, mais je ne l'apprendre avant d'apprendre java et ils sont à proximité des langues.

Une possible baisse des instructions de commutation est son manque de multiples conditions. Vous pouvez avoir plusieurs conditions pour le si (le reste), mais pas de cas multiples déclarations avec des conditions différentes dans un commutateur.

Instructions de commutation ne sont pas adaptés pour les opérations logiques au-delà de la portée de Booléenne simple des équations et des expressions. Pour ceux équations Booléennes/expressions, il est tout à fait adéquate, mais pas pour d'autres opérations logiques.

Vous avez beaucoup plus de liberté avec la logique disponible dans les instructions if, mais la lisibilité peut souffrir si la Si la déclaration devient lourd ou mal traités.

Les deux ont leur place en fonction du contexte, de ce que vous êtes confrontés.