Déclaration de commutation C# avec/sans accolades .... quelle est la différence?

Question

Est-ce que C# vous a toujours permis d'omettre les accolades dans une instruction switch() entre les instructions case:? 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 
} 

Answer 1

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

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

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

Four switch oddities

exemple de 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 parce que int y et double y sont dans le même espace de déclaration introduit par le e switch déclaration.Vous pouvez corriger l'erreur en séparant les espaces de déclaration en utilisant des accolades:

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

Answer 2

Les accolades sont une partie facultative de la switch block, ils ne font pas partie des sections de commutation. Les accolades peuvent être insérées dans des sections de commutateur ou insérées n'importe où pour contrôler la portée de votre code.

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

int x = 5; 

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

vs ...

int x = 5; 

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

Note: C# vous demandera de définir une valeur pour y dans le cas 5 bloc dans le premier exemple avant de l'utiliser. C'est la protection contre le suivi accidentel variable.

Answer 3

Ils ne sont pas strictement nécessaires mais dès que vous commencez à déclarer des variables locales (dans les branches du commutateur), ils sont fortement recommandés.

Cela ne fonctionnera pas:

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

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

Cette compile, mais il est la chair de poule:

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

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

Donc, c'est le meilleur:

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

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

Il suffit de rester 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.

Answer 4

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

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, qui ne sont pas en conflit avec d'autres variables d'une autre portée.

Exemple:

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