web-dev-qa-db-fra.com

Instruction C # Switch avec / sans accolades ... quelle est la différence?

C # vous a-t-il toujours permis d'omettre les accolades dans une instruction switch() entre les case: déclarations?

Quel est l'effet de les omettre, comme le font souvent les programmeurs javascript?

Exemple:

switch(x)
{
  case OneWay:
  {                               //  <---- Omit this entire line
    int y = 123;
    FindYou(ref y);
    break;
  }                               //  <---- Omit this entire line
  case TheOther:
  {                               //  <---- Omit this entire line
    double y = 456.7; // legal!
    GetchaGetcha(ref y);
    break;
  }                               //  <---- Omit this entire line
}
c#switch-statementcurly-braces
70
goodguys_activate

Les accolades ne sont pas nécessaires, mais elles pourraient être utiles pour introduire un nouvel espace de déclaration . Ce comportement n'a pas changé depuis C # 1.0 pour autant que je sache.

L'effet de leur omission est que toutes les variables déclarées quelque part à l'intérieur de l'instruction switch sont visibles depuis leur point de déclaration dans toutes les branches de cas.

Voir aussi l'exemple d'Eric Lippert (cas 3 dans le billet):

Quatre bizarreries de commutation

Exemple d'Eric:

switch(x)
{
  case OneWay:
    int y = 123;
    FindYou(ref y);
    break;
  case TheOther:
    double y = 456.7; // illegal!
    GetchaGetcha(ref y);
    break;
}

Cela ne compile pas car int y et double y sont dans le même espace de déclaration introduit par l'instruction switch. Vous pouvez corriger l'erreur en séparant les espaces de déclaration à l'aide d'accolades:

switch(x)
{
  case OneWay:
  {
    int y = 123;
    FindYou(ref y);
    break;
  }
  case TheOther:
  {
    double y = 456.7; // legal!
    GetchaGetcha(ref y);
    break;
  }
}
102
Dirk Vollmar

Les accolades sont une partie facultative du bloc de commutation , ils ne font pas partie des sections de commutation. Les accolades peuvent être insérées dans des sections de commutateur ou également insérées n'importe où pour contrôler l'étendue de votre code.

Ils peuvent être utiles pour limiter la portée dans le bloc commutateur. Par exemple:

int x = 5;

switch(x)
{
case 4:
    int y = 3;
    break;
case 5:
    y = 4;
    //...                      
    break;
}

contre...

int x = 5;

switch(x)
{
  case 4:
  {
    int y = 3;
    break;
  }
  case 5:
  {
    y = 4;//compiling error
    //...                      
    break;
  }
}

Remarque: C # vous obligera à définir une valeur à y dans le bloc de cas 5 dans le premier exemple avant de l'utiliser. Il s'agit d'une protection contre le suivi accidentel des variables.

14
Brian R. Bondy

Les accolades à l'intérieur du commutateur ne font en fait pas partie de la structure du commutateur. Ce ne sont que des blocs de portée, que vous pouvez appliquer dans le code où vous le souhaitez.

La différence entre les avoir et ne pas les avoir est que chaque bloc a sa propre portée. Vous pouvez déclarer des variables locales à l'intérieur de la portée, ce qui n'entre pas en conflit avec d'autres variables dans une autre portée.

Exemple:

int x = 42;
{
  int y = x;
}
{
  int y = x + 1; // legal, as it's in a separate scope
}
8
Guffa

Elles ne sont pas strictement nécessaires mais dès que vous commencez à déclarer des variables locales (dans les branches de commutation), elles sont fortement recommandées.

Cela ne fonctionnera pas:

    // does not compile
    switch (x)
    {
        case 1 :               
            int j = 1;
            ...
            break;

        case 3:
            int j = 3;   // error
            ...
            break;
    }

Cela compile mais c'est effrayant:

    switch (x)
    {
        case 1 :               
            int j = 1;
            ...
            break;

        case 3:
            j = 3;
            ...
            break;
    }

Donc c'est mieux:

  switch (x)
    {
        case 1 : 
         {             
            int j = 1;
            ...
         }
         break;  // I prefer the break outside of the  { }

        case 3: 
         {
            int j = 3;
            ...
         }
         break;
    }

Restez simple et lisible. Vous ne voulez pas obliger les lecteurs à avoir une connaissance détaillée des règles impliquées dans l'exemple du milieu.

4
Henk Holterman