Dans C#, l’instruction Switch est une instruction de branche multiway. Il fournit un moyen efficace de transférer l’exécution à différentes parties d’un code en fonction de la valeur de l’expression. L’expression du commutateur est de type entier tel que l’itt, l’omble, l’octet ou le court, ou d’un type d’énumération ou de type de chaîne. L’expression est vérifiée pour différents cas et la correspondance est exécutée.
Syntaxe:
switch (expression) {
case valeur1: // séquence d’instructions
break;
case valeur2: // séquence d’instructions
break;
case valeur3: // séquence d’instructions
break;
default: // séquence d’instructions par défaut
Points importants à retenir :
-
- En C#, les valeurs de cas en double ne sont pas autorisées.
- Le type de données de la variable dans le commutateur et la valeur d’un boîtier doit être du même type.
- La valeur d’un cas doit être une constante ou une littérale. Les variables ne sont pas autorisées.
- L’instruction de rupture dans l’instruction de commutateur est utilisée pour terminer la séquence en cours.
- L’instruction par défaut est facultative et peut être utilisée n’importe où à l’intérieur de l’instruction de commutateur.
- Plusieurs instructions par défaut ne sont pas autorisées.
Exemple:
// C# program to illustrate
// switch case statement
using System;
public class SC {
// Main Method
public static void Main(String[] args)
{
int numCase= 4;
switch (numCase) {
case 1:
Console.WriteLine(“numéro case 1”);
break;
case 4:
Console.WriteLine(“numéro case 4”);
break;
case 8:
Console.WriteLine(“numéro case 8”);
break;
default:
Console.WriteLine(“No match found”);
break;
}
}
}Sortie: numéro case 4
Pourquoi utilisons-nous les instructions switch au lieu des instructions if-else ?
Nous utilisons une instruction de commutateur au lieu d’instructions if-else parce que l’instruction if-else ne fonctionne que pour un petit nombre d’évaluations logiques d’une valeur. Si vous utilisez l’instruction if-else pour un plus grand nombre de conditions possibles, il faut plus de temps pour écrire et aussi devenir difficile à lire.
Exemple : Utilisation de l’instruction if-else-if
// C# program to illustrate
// if-else statement
using System;
class SC{
// Main Method
public static void Main(String[] args)
{
// taking two strings value
string topic;
string category;
// taking topic name
topic = “Objets et Classes”;
// en utilisant la fonction de comparaison de la classe de chaîne
if ((String.Compare(topic, “Introduction à C#”) == 0) || (String.Compare(topic, “Variables”) == 0) || (String.Compare(topic, “Types de données “) == 0))
{
category = “Basic”;
}
// en utilisant la fonction de comparaison de la classe de chaîne
else if ((String.Compare(topic, “Boucles”) == 0) || (String.Compare(topic, “Instructions If”) == 0) || (String.Compare(topic, “Instructions Jump”) == 0))
{
category = “Flux de contrôle”;
}
// en utilisant la fonction de comparaison de la classe de chaîne
else if ((String.Compare(topic, “Objets et Classes”) == 0) || (String.Compare(topic, “Héritage”) == 0) || (String.Compare(topic, “Constructeurs”) == 0))
{
category = “Concept OOPS”;
}
else
{
category = “Not Mentioned”;
}
System.Console.Write(“La Catégorie est ” + category);
}
}
Sortie: La Catégorie est Concept OOPS
Explication: Comme indiqué dans le programme ci-dessus le code n’est pas excessif, mais, il semble compliqué à lire et a pris plus de temps à écrire. Nous utilisons donc une instruction de commutateur pour gagner du temps et écrire du code optimisé. L’utilisation de l’instruction switch fournira une meilleure lisibilité du code.
Exemple : Utilisation de l’instruction Switch
// C# program to illustrate
// switch statement
using System;
class SC {
// Main Method
public static void Main(String[] args)
{
// taking two strings value
string topic;
string category;
// taking topic name
topic = “Instructions If”;
// using switch Statement
switch(topic)
{
case “Introduction à C#”:
case “Variables”:
case “Types de données”:
category = “Basic”;
break;
case “Boucles”:
case”Instructions If”:
case”Instructions Jump”:
category = “Contrôle du flux”;
break;
case “Objets et Classes”:
case “Héritage”:
case “Constructeurs”:
category = “Concept OOPS”;
break;
// default case
default:
category = “Not Mentioned”;
break;
}
System.Console.Write(“La catégorie est ” + category);
}
}
Sortie: La catégorie est Contrôle du flux
Utilisation de goto dans l’instruction Switch
Vous pouvez également utiliser l’instruction goto à la place de la pause dans l’instruction switch. En général, nous utilisons une instruction de rupture pour sortir de l’instruction de commutateur. Mais dans certaines situations, l’instruction par défaut doit être exécutée, nous utilisons donc l’instruction goto. Il permet d’exécuter la condition par défaut dans l’instruction de commutateur. L’instruction goto est également utilisée pour sauter à un emplacement étiqueté dans le programme C#.
Exemple:
// C# programme pour illustrer l’utilisation
//de goto dans une instruction switch
using System;
public class SC {
// Main Method
public static void Main(String[] args)
{
int salutations= 2;
switch (salutations) {
case 1:
Console.WriteLine(“Hello”);
goto default;
case 2:
Console.WriteLine(“Bonjour”);
goto case 3;
case 3:
Console.WriteLine(“Marhabaan”);
goto default;
default:
Console.WriteLine(“Valeur donnée est : ” + salutations);
break;
}
}
}
Sortie: Bonjour Marhabaan
Valeur donnée est: 2
Explication: Dans le programme ci-dessus, l’instruction goto est utilisée dans une instruction de commutateur. Ici d’abord le cas 2, c’est-à-dire Bonjour est imprimé parce que le commutateur contient la valeur de salutation est 2, puis les transferts de contrôle au cas 3 en raison de la présence de l’instruction goto, de sorte qu’il imprime Marhabaan et en dernier le transfert de contrôle à la condition par défaut et l’impression entrée valeur est: 2.
Remarque : Vous pouvez également utiliser continuer à la place d’une instruction de rupture dans le commutateur si votre instruction de commutateur fait partie d’une boucle, puis continuer l’instruction entraînera l’exécution de revenir instantanément au début de la boucle.