După cum vom vedea, instrucțiunea condițională switch funcționează foarte asemănător cu If-Else If-Else cu o mică diferență de sintaxă. Execută o instrucțiune bazată pe valoarea calculată a unei condiții. Formatul instrucțiunii switch este următorul:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
switch (conditie)
{
case valoare1:
instructiuni;
break;
case valoare2:
instructiuni;
break;
case valoare3:
instructiuni;
break;
// ...
default:
instructiuni;
break;
}
}
}
}
|
Codul de mai sus ar fi putut fi scris și ca:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
if (conditie == valoare1)
instructiuni;
else if (conditie == valoare2)
instructiuni;
else if (conditie == valoare3)
instructiuni;
// ...
else
instructiuni;
}
}
}
|
Avem o condiție, pentru care verificăm dacă rezultatul său este egal cu valoare1, și executăm anumite instrucțiuni dacă acest lucru este adevărat; dacă nu, vom verifica rezultatul față de valoarea următoare, valoare2, executând alte instrucțiuni dacă rezultatul verificării este adevărat, și așa mai departe. În cele din urmă, în cazul în care nici una dintre condiții nu este adevărată, avem instrucțiunea default, care este similară cu declarația else și care se execută numai în cazul în care nici una dintre valori nu corespunde valoarii condiției.
În afară de aceasta, ați observat cuvântul cheie break. După cum știți deja, o declarație switch efectuează o procesare condițională, și puteți defini unul sau mai multe cazuri posibile în raport cu care se poate verifica valoarea condiției. Pentru fiecare caz, vom specifica instrucțiunile care vrem să fie executate atunci când acest caz este adevărat, și o instrucțiune break, la sfârșitul instrucțiunilor, pentru a separa o instrucțiune case de alta. Dacă nu puneți o instrucțiune break, execuția va continua cu instrucțiunile care urmează, fără a mai testa cazul cu care aceste instrucțiuni sunt asociate. Să considerăm următorul exemplu:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
char caracter = 'A';
switch (caracter)
{
case 'A': Console.WriteLine("Caracterul este A");
case 'B': Console.WriteLine("Caracterul este B");
case 'C': Console.WriteLine("Caracterul este C");
}
}
}
}
|
Programul verifică dacă variabila character este egal cu caracterul A și execută o instrucțiune, dacă acest lucru este true, afișând mesajul "Caracterul este A". Totul bine până acum. Cu toate acestea, pentru că nici o instrucțiune break nu urmează, programul va continua execuția și va afișa, de asemenea, mesajele "Caracterul este B" și "Caracterul este C". Din acest motiv, în cazul în care nu există un cod după declarația case, instrucțiunea break poate fi omisă, deoarece programul va sări pur și simplu la următoarea instrucțiune case, până când va găsi un operator break. Totuși, după cazul default, o instrucțiune break este obligatorie.
De asemenea, puteți utiliza mai multe cazuri pentru aceeași instrucțiune, după cum urmează:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
int numar = 8;
switch (numar)
{
case 1:
case 3:
case 5:
case 7:
Console.WriteLine("Numărul este impar");
break;
case 2:
case 4:
case 6:
case 8:
Console.WriteLine("Numărul este par");
break;
default:
Console.WriteLine("Număr necunoscut");
break;
}
}
}
}
|
Sunt momente în care numărul de cazuri posibile este limitat, și le verificăm pe toate. Într-un astfel de caz, este recomandabil să plasați o verificare default în care aveți posibilitatea de a afișa de exemplu, un mesaj de eroare.
Este considerată o bună practică să plasați cazul default la sfârșitul tuturor celorlalte cazuri.
În C# 8.0, a fost introdusă o modalitate mai scurtă și mai expresivă de a trata mai multe cazuri și de a returna valori în funcție de condiții: switch expressions. Acestea oferă o sintaxă concisă pentru asignarea valorilor pe baza unei condiții. Iată cum funcționează expresiile switch:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
using
System;
namespace
BunaLume
{
class
Program
{
static void Main(string[] args)
{
var rezultat = conditie switch
{
valoare1 => instructiuni,
valoare2 => instructiuni,
valoare3 => instructiuni,
// ...
_ => instructiuni implicite
};
}
}
}
|
Expresia switch are ca primă parte condiția, urmată de cuvântul cheie switch. Fiecare valoare este asociată cu o expresie, folosind operatorul =>. Atunci când condiția se potrivește cu o valoare, expresia corespunzătoare este evaluată și atribuită variabilei rezultat. Dacă nici unul dintre cazuri nu se potrivește, _ (variabila de ignorare) reprezintă cazul default, implicit, și instrucțiunile implicite sunt atribuite. Prin utilizarea liniuței de jos, indicați că nu este necesar să tratați sau să atribuiți o valoare specifică. Aceasta acționează ca un element special pentru prinderea oricăror valori care nu se potrivesc cazurilor definite în mod explicit. Acest lucru poate fi util atunci când doriți să tratați doar cazuri specifice și să oferiți un comportament implicit pentru toate celelalte cazuri.
Expresiile switch oferă o alternativă mai concisă și mai ușor de citit față de instrucțiunile if-else pentru condiții simple. Ele sunt deosebit de utile atunci când se atribuie valori pe baza mai multor condiții. Totuși, pot să nu fie cele mai potrivite atunci când logica e complexă.
Conceptele explicate în această lecție sunt prezentate și vizual, ca parte a următorului videoclip:
