“sinon si()” et plusieurs “si()”s en C#

Comment ces pratiquement diffèrent-ils?

//Approach one
if (x == 1)
    DoSomething();
else if (x == 2)
    DoSomethingElse();

//Approach two
if (x == 1)
    DoSomething();
if (x == 2)
    DoSomethingElse();

Est le CIL de la même manière?

_{(La question L'utilisation de “if/elseif/else” et “if/else{if/else}” existe, mais il est encore sans réponse.)}

OriginalL'auteur Jerry Nixon - MSFT | 2013-01-16

37

Si DoSomething jeux de x à 2, alors qu'ils diffèrent.

Merci, vous. Donc, y compris else contiendra le champ d'application de l'ensemble du si de sorte qu'il s'exécute automatiquement. Cela fait sens pour moi. Je ne l'aurais cru. Des acclamations.
Quelque chose comme ça! Grammaticalement parlant, la première démarche est identique à if(...) { ... } else { if(...) { ... } }.

OriginalL'auteur Oliver Charlesworth

[STAThread]
public static void Main()
{
    Int32 x = 1;

    if (x == 1)
        Console.WriteLine("1");
    else if (x == 2)
        Console.WriteLine("2");
}

Résultats dans:

.method public hidebysig static void Main() cil managed
{
    .custom instance void [mscorlib]System.STAThreadAttribute::.ctor()
    .entrypoint
    .maxstack 2
    .locals init (
        [0] int32 x)
    L_0000: ldc.i4.1 
    L_0001: stloc.0 
    L_0002: ldloc.0 
    L_0003: ldc.i4.1 
    L_0004: bne.un.s L_0011
    L_0006: ldstr "1"
    L_000b: call void [mscorlib]System.Console::WriteLine(string)
    L_0010: ret 
    L_0011: ldloc.0 
    L_0012: ldc.i4.2 
    L_0013: bne.un.s L_001f
    L_0015: ldstr "2"
    L_001a: call void [mscorlib]System.Console::WriteLine(string)
    L_001f: ret 
}

Tout:

[STAThread]
public static void Main()
{
    Int32 x = 1;

    if (x == 1)
        Console.WriteLine("1");

    if (x == 2)
        Console.WriteLine("2");
}

Résultats dans:

.method public hidebysig static void Main() cil managed
{
    .custom instance void [mscorlib]System.STAThreadAttribute::.ctor()
    .entrypoint
    .maxstack 2
    .locals init (
        [0] int32 x)
    L_0000: ldc.i4.1 
    L_0001: stloc.0 
    L_0002: ldloc.0 
    L_0003: ldc.i4.1 
    L_0004: bne.un.s L_0010
    L_0006: ldstr "1"
    L_000b: call void [mscorlib]System.Console::WriteLine(string)
    L_0010: ldloc.0 
    L_0011: ldc.i4.2 
    L_0012: bne.un.s L_001e
    L_0014: ldstr "2"
    L_0019: call void [mscorlib]System.Console::WriteLine(string)
    L_001e: ret 
}

Code IL est un peu différent et c'est ici la principale différence:

Approach One: L_0004: bne.un.s L_0011 -> L_0011: ldloc.0 with L_0010: ret 
Approach Two: L_0004: bne.un.s L_0010 -> L_0010: ldloc.0 with no ret in between

Lorsque vous utilisez l'instruction else, comme dans la première approche, seule la première branche qui répond à la condition sera exécuté. Sur l'autre main... avec la deuxième approche, chaque case est traitée et toutes les cases qui répond à la condition d'être suivie et traitée. C'est la principale différence.

C'est pourquoi dans la première approche, IL code vous avez un "ret" directive juste après l'appel de la Console.WriteLine alors que dans le second il n'est pas présent. Dans le premier cas, la méthode ne peut être quitté juste après une vérification a été adopté en raison de pas plus de contrôles sur les x sera effectué... dans la seconde approche, vous avez pour suivre toutes l'une après l'autre et c'est pourquoi ret est seulement apparaissant à la fin de la méthode, pas de "raccourcis" à la fin.

Pour mon test, j'ai utilisé un Console.WriteLine() appel... mais c'est sûr que si DoSomething() implique une modification de la valeur d' x variable, la différence sera absolument plus important dans le comportement du code. Disons que nous avons x privé de membre statique (valeur initiale toujours 1) au lieu d'une variable locale et:

public void DoSomething()
{
    ++m_X;
}

Dans la première approche, même si m_X suppose une valeur de 2 après DoSomething() est appelé grâce à la première vérification, d'autre prendra la méthode de sortie et DoSomethingElse() ne sera jamais appelé. Dans la deuxième approche, les deux méthodes seront appelées.

Plus un pour la réponse détaillée couvrant la totalité du sujet. J'ai été la recherche de la performance de pannes sur ce sujet.

OriginalL'auteur Tommaso Belluzzo

13

Noter qu'il n'y a pas de else if construire en C#. Votre premier exemple de code est exactement le même que:
```
if (x == 1)
    DoSomething();
else 
{
    if (x == 2)
        DoSomethingElse();
}
```
Car il n'existe qu'une seule instruction dans else, les accolades peuvent être omis, et pour une meilleure lisibilité, if est généralement écrit sur la même ligne que le précédent,else. L'écriture de plusieurs "else if" états est équivalent à plus de nidification:
```
if (x == 1)
    DoSomething();
else 
{
    if (x == 2)
        DoSomethingElse();
    else
    {
        if (x == 3)
            YetSomethingElse();
        else
        {
            if (x == 4)
               ReallyDifferent();
        }
    }
}
```
Ci-dessus peut être écrite comme:
```
if (x == 1)
    DoSomething();
else if (x == 2)
    DoSomethingElse();
else if (x == 3)
    YetSomethingElse();
else if (x == 4)
    ReallyDifferent();
```
De cela, vous pouvez voir que le chaînage "else if" et if peut produire des résultats différents. En cas de "else if", la première branche qui répond à la condition sera exécutée, et après que aucune vérification supplémentaire n'est effectuée. En cas de enchaînés if états, de toutes les branches qui répondent à leurs conditions d'exécution.

La principale différence ici, c'est lors de l'exécution d'une branche provoque un état ultérieur. Par exemple:
```
   var x = 1;

   if (x == 1)
       x = 2;
   else if (x == 2)
       x = 3;
```
VS
```
   var x = 1;

   if (x == 1)
       x = 2;

   if (x == 2)
       x = 3;
```
Dans le premier cas, x == 2, tandis que dans le second cas x == 3.

OriginalL'auteur Bojan Resnik
9

Lorsque l'on code comme ceci
```
//approach two
if (x == 1)
    DoSomething();
if (x == 2)
    DoSomethingElse();
```
Chaque fois que la condition des contrôles.

Mais lorsque l'on code comme ceci
```
if (x == 1)
    DoSomething();
else if (x == 2)
    DoSomethingElse();
```
Si la première condition est vraie, alors il l'habitude de la coche à côté de l'autre, s'condition et ainsi diminuer inutile de compiler.

Merci, Ravi. Je vous remercie de votre contribution à cette discussion. Et, vous avez raison à 100%. C'est la façon dont il fonctionne.
tu veux dire diminution de l'élément de contrôles. Car la compilation-sage, je ne vois pas ce qui va diminuer avec le temps!

OriginalL'auteur
5

Lorsque vous utilisez else déclaration, une seule des branches sera exécutée (c'est à dire la première, qui répond à la if condition). Tous les autres if conditions de ne pas même être estimé:
```
//approach one
int x = 1;
if (x == 1)
    DoSomething(); //only this will be run, even if `DoSomething` changes `x` to 2
else if (x == 2)
    DoSomethingElse();
```
Alors que quand vous ne l'utilisez pas chacun d'entre eux peut être, en fonction de chacune des conditions), c'est à dire chacun d'entre eux est d'environ un par un:
```
//approach two
int x = 1;
if (x == 1)
    DoSomething();//this is run, as `x` == 1
if (x == 2)
    DoSomethingElse();//if `DoSomething` changes `x` to 2, this is run as well
```
Donc, IL peut différer.

Peut-être remplacer x == 2 avec x < 2 de montrer pourquoi.

OriginalL'auteur horgh
4

Pas anwsers sur les performances?

Donc, si x=1 alors vous n'avez qu'une seule case dans le premier cas, et dans le deuxième cas, il n'2 contrôles, de sorte que le premier cas est plus rapide.

OriginalL'auteur Gumowy Kaczak
3

Si x change (en Ne Seomthing et DoSomethingElse) puis la première instruction de ne jamais exécuter une instruction. Dans le 2ème exemple toutes les déclarations seront vérifiées (sauf bien sûr si le compilateur optimise pour un saut de la table pour le nombre de comparaison).

OriginalL'auteur Jesus Ramos
3

Lorsque vous utilisez plusieurs else if, il exécutera la condition que satisfait. Si il y a des cas restants, ils seront ignorés. Lorsque vous avez plusieurs if, il va vérifier à chaque instruction. Donc, cela devient de plus en plus d'un problème de performances.

OriginalL'auteur drum
2

Si x est modifié par plusieurs threads, il est possible que DoSomething() et DoSomethingElse() permettra à la fois d'être appelé avec la deuxième approche

OriginalL'auteur JG in SD
2

Else if sera évaluée uniquement si la première condition n'était pas vrai. Mais deux années consécutives si des instructions seront évalués.

Vous pouvez facilement tester ce concept dans un L'interpréteur Python:

De la première exécution de cette:

Remarque: En Python elif est utilisé à la place de l'autre, s'
```
a = 1
if a >= 1:
  print('a is greater than or equal to 1')
elif a<=1:
  print('a is less than or equal to 1')
```
puis exécutez ce
```
a=1
if a >= 1:
  print('a is greater than or equal to 1')
if a<=1:
  print('a is less than or equal to 1')
```
OriginalL'auteur Don't Know

Vous devez vous connecter pour publier un commentaire.