Istruzioni e cicli C# if - Esercitazione sulla logica condizionale

Questa esercitazione illustra come scrivere codice C# che esamina le variabili e modifica il percorso di esecuzione in base a tali variabili. Verranno descritte le procedure per scrivere codice C# e visualizzare i risultati della compilazione ed esecuzione del codice. L'esercitazione contiene una serie di lezioni che esplorano i costrutti per rami e cicli in C#. Queste lezioni presentano le nozioni fondamentali del linguaggio C#.

Suggerimento

Per incollare un frammento di codice all'interno della modalità di messa a fuoco, è consigliabile usare il tasto di scelta rapida (CTRL + v o cmd + v).

Prerequisiti

L'esercitazione prevede che sia stato configurato un computer per lo sviluppo locale. Vedere Configurare l'ambiente locale per le istruzioni di installazione e una panoramica dello sviluppo di applicazioni in .NET.

Se si preferisce eseguire il codice senza dover configurare un ambiente locale, vedere la versione interattiva in-browser di questa esercitazione.

Prendere decisioni usando l'istruzione if

Creare una directory denominata branches-tutorial. Impostare la directory corrente ed eseguire il comando seguente:

dotnet new console -n BranchesAndLoops -o .

Importante

I modelli C# per .NET 6 usano istruzioni di primo livello. L'applicazione potrebbe non corrispondere al codice in questo articolo, se è già stato eseguito l'aggiornamento a .NET 6. Per altre informazioni, vedere l'articolo sui nuovi modelli C# genera istruzioni di primo livello

.NET 6 SDK aggiunge anche un set di direttive impliciteglobal using per i progetti che usano gli SDK seguenti:

• Microsoft.NET.Sdk
• Microsoft.NET.Sdk.Web
• Microsoft.NET.Sdk.Worker

Queste direttive implicite global using includono gli spazi dei nomi più comuni per il tipo di progetto.

Per altre informazioni, vedere l'articolo sull'uso implicito delle direttive

Questo comando crea una nuova applicazione console .NET nella directory corrente. Aprire Program.cs nell'editor preferito e sostituire il contenuto con il codice seguente:

int a = 5;
int b = 6;
if (a + b > 10)
    Console.WriteLine("The answer is greater than 10.");

Per provare questo codice, digitare dotnet run nella finestra della console. Verrà visualizzato il messaggio "La risposta è maggiore di 10." stampata nella console. Modificare la dichiarazione di b in modo che la somma sia minore di 10:

int b = 3;

Digitare di nuovo dotnet run. Dato che la risposta è minore a 10, non viene visualizzato nulla. La condizione testata è false. Non esiste codice da eseguire perché è stato scritto solo uno dei possibili rami per un'istruzione if, ovvero il ramo true.

Suggerimento

Mentre si impara a usare C# (o qualsiasi linguaggio di programmazione) sicuramente si commetteranno errori durante la scrittura del codice. Il compilatore troverà e segnalerà gli errori. Esaminare attentamente l'output dell'errore e il codice che ha generato l'errore. L'errore del compilatore consente in genere di trovare il problema.

Questo primo esempio dimostra le potenzialità di if e dei tipi booleani. Un valore booleano è una variabile che può avere uno di due valori: true o false. C# definisce un tipo speciale, bool per le variabili booleane. L'istruzione if controlla il valore di un bool. Quando il valore è true, viene eseguita l'istruzione che segue if. In caso contrario, viene ignorato. Questo processo di verifica delle condizioni e dell'esecuzione di istruzioni basate su queste condizioni è potente.

Usare insieme if ed else

Per eseguire codice diverso per i rami true e false, è necessario creare un ramo else che viene eseguito quando la condizione è false. Provare un else ramo. Aggiungere le ultime due righe nel codice seguente (si dovrebbe già avere le prime quattro):

int a = 5;
int b = 3;
if (a + b > 10)
    Console.WriteLine("The answer is greater than 10");
else
    Console.WriteLine("The answer is not greater than 10");

L'istruzione che segue la parola chiave else viene eseguita solo quando la condizione testata è false. La combinazione di if e else con condizioni booleane offre tutte le potenzialità necessarie per gestire sia una condizione true che una condizione false.

Importante

Il rientro applicato alle righe successive alle istruzioni if e else è pensato per i lettori umani. Nel linguaggio C# i rientri o gli spazi vuoti non sono significativi. L'istruzione che segue la parola chiave if o else verrà eseguita in base alla condizione. Tutti gli esempi in questa esercitazione seguono una procedura comune che prevede il rientro delle righe in base al flusso di controllo delle istruzioni.

Poiché il rientro non è significativo, è necessario usare { e } indicare quando si desidera che più istruzioni facciano parte del blocco che esegue in modo condizionale. I programmatori C# usano in genere le parentesi graffe in tutte le clausole if e else. L'esempio seguente è uguale a quello creato. Modificare il codice precedente in modo che corrisponda al codice seguente:

int a = 5;
int b = 3;
if (a + b > 10)
{
    Console.WriteLine("The answer is greater than 10");
}
else
{
    Console.WriteLine("The answer is not greater than 10");
}

Suggerimento

Nelle parti restanti di questa esercitazione, tutti gli esempi di codice includono le parentesi graffe conformemente alle consuetudini comuni.

È possibile testare condizioni più complesse. Aggiungere il codice seguente dopo che il codice scritto finora:

int c = 4;
if ((a + b + c > 10) && (a == b))
{
    Console.WriteLine("The answer is greater than 10");
    Console.WriteLine("And the first number is equal to the second");
}
else
{
    Console.WriteLine("The answer is not greater than 10");
    Console.WriteLine("Or the first number is not equal to the second");
}

Il simbolo == verifica l'uguaglianza. Il simbolo == distingue il test per l'uguaglianza dall'assegnazione, illustrata in a = 5.

&& rappresenta "e" e significa che entrambe le condizioni devono essere true per eseguire l'istruzione nel ramo true. Questi esempi mostrano anche che è possibile includere più istruzioni in ogni ramo condizionale, a condizione di racchiuderle tra { e }. È anche possibile usare || per rappresentare "o". Aggiungere il codice seguente dopo il codice già scritto finora:

if ((a + b + c > 10) || (a == b))
{
    Console.WriteLine("The answer is greater than 10");
    Console.WriteLine("Or the first number is equal to the second");
}
else
{
    Console.WriteLine("The answer is not greater than 10");
    Console.WriteLine("And the first number is not equal to the second");
}

Modificare i valori di a, b e c e passare da && a || per esplorare. Si otterranno più informazioni sul funzionamento degli operatori && e ||.

Il primo passaggio è stato completato. Prima di iniziare la sezione successiva, è necessario spostare il codice corrente in un metodo separato. In questo modo sarà più semplice iniziare a lavorare con un nuovo esempio. Inserire il codice esistente in un metodo denominato ExploreIf(). Chiamalo dall'inizio del tuo programma. Al termine di queste modifiche, il codice dovrebbe essere simile al seguente:

ExploreIf();

void ExploreIf()
{
    int a = 5;
    int b = 3;
    if (a + b > 10)
    {
        Console.WriteLine("The answer is greater than 10");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
    }

    int c = 4;
    if ((a + b + c > 10) && (a > b))
    {
        Console.WriteLine("The answer is greater than 10");
        Console.WriteLine("And the first number is greater than the second");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
        Console.WriteLine("Or the first number is not greater than the second");
    }

    if ((a + b + c > 10) || (a > b))
    {
        Console.WriteLine("The answer is greater than 10");
        Console.WriteLine("Or the first number is greater than the second");
    }
    else
    {
        Console.WriteLine("The answer is not greater than 10");
        Console.WriteLine("And the first number is not greater than the second");
    }
}

Impostare come commento la chiamata a ExploreIf(). L'output risulterà in questo modo meno disordinato quando si usa questa sezione:

//ExploreIf();

// avvia un commento in C#. Un commento è un testo che si vuole conservare nel codice sorgente senza eseguirlo come codice. Il compilatore non genera codice eseguibile dai commenti.

Usare i cicli per ripetere le operazioni

In questa sezione vengono usati cicli per ripetere le istruzioni. Aggiungere questo codice dopo la chiamata a ExploreIf:

int counter = 0;
while (counter < 10)
{
    Console.WriteLine($"Hello World! The counter is {counter}");
    counter++;
}

L'istruzione while verifica una condizione ed esegue l'istruzione o il blocco di istruzioni che segue while. Verifica ripetutamente la condizione, eseguendo tali istruzioni fino a quando la condizione non è false.

Questo esempio include un altro operatore nuovo. I caratteri ++ dopo la variabile counter rappresentano l'operatore di incremento. Questo operatore aggiunge 1 al valore di counter e archivia il valore nella variabile counter.

Importante

Assicurarsi che la condizione del ciclo while passi a false quando si esegue il codice. In caso contrario, si crea un ciclo infinito in cui il programma non termina mai. Tale situazione non è illustrata in questo esempio, perché è necessario forzare l'uscita dal programma usando CTRL+C o in altro modo.

Il ciclo while testa la condizione prima di eseguire il codice dopo while. Il ciclo do ... while esegue prima il codice e poi controlla la condizione, Il ciclo do while è illustrato nel codice seguente:

int counter = 0;
do
{
    Console.WriteLine($"Hello World! The counter is {counter}");
    counter++;
} while (counter < 10);

Questo ciclo do e il ciclo while precedente generano lo stesso output.

Usare il ciclo for

Il ciclo for viene in genere usato in C#. Provare questo codice:

for (int index = 0; index < 10; index++)
{
    Console.WriteLine($"Hello World! The index is {index}");
}

Il codice precedente funziona allo stesso modo del while ciclo e del do ciclo già usato. L'istruzione for è composta da tre parti che ne controllano il funzionamento.

La prima parte è l'oggetto per l'inizializzatore: int index = 0; dichiara che index è la variabile del ciclo e imposta il valore iniziale su 0.

La parte centrale è la condizione per: index < 10 dichiara che questo for ciclo continua a essere eseguito finché il valore del contatore è minore di 10.

La parte finale è l'iteratore: index++ specifica come modificare la variabile del ciclo dopo l'esecuzione del blocco dopo l'istruzione for . In questo caso, specifica che index deve essere incrementato di 1 a ogni esecuzione del blocco.

Sperimentare te stesso. Provare ognuna delle varianti seguenti:

• Cambiare l'inizializzatore in modo che inizi da un valore diverso.
• Cambiare la condizione in modo che si interrompa in corrispondenza di un valore diverso.

Al termine, passare alla prossima lezione che prevede la scrittura di codice per usare quanto finora appreso.

In questa esercitazione non è illustrata un'altra istruzione di ciclo: l'istruzione foreach . L'istruzione ripete l'istruzione foreach per ogni elemento in una sequenza di elementi. Viene usato più spesso con le raccolte, quindi viene trattato nell'esercitazione successiva.

Cicli annidati creati

Un whileciclo , doo for può essere annidato all'interno di un altro ciclo per creare una matrice usando la combinazione di ogni elemento nel ciclo esterno con ogni elemento nel ciclo interno. A questo scopo, creare un set di coppie alfanumerici per rappresentare righe e colonne.

Un for ciclo può generare le righe:

for (int row = 1; row < 11; row++)
{
    Console.WriteLine($"The row is {row}");
}

Un altro ciclo può generare le colonne:

for (char column = 'a'; column < 'k'; column++)
{
    Console.WriteLine($"The column is {column}");
}

È possibile annidare un ciclo all'interno dell'altro per formare coppie:

for (int row = 1; row < 11; row++)
{
    for (char column = 'a'; column < 'k'; column++)
    {
        Console.WriteLine($"The cell is ({row}, {column})");
    }
}

È possibile notare che il ciclo esterno viene incrementato una volta per ogni esecuzione completa del ciclo interno. Invertire l'annidamento di righe e colonne e visualizzare le modifiche. Al termine, inserire il codice di questa sezione in un metodo denominato ExploreLoops().

Combinare rami e cicli

Dopo aver esaminato l'istruzione if e i costrutti per i cicli nel linguaggio C#, provare a scrivere codice C# per ottenere la somma di tutti i numeri interi da 1 a 20 divisibili per 3. Ecco alcuni suggerimenti:

• L'operatore % restituisce il resto di un'operazione di divisione.
• L'istruzione if offre la condizione per stabilire se un numero deve fare parte della somma.
• Il ciclo for può essere utile per ripetere una serie di passaggi per tutti i numeri da 1 a 20.

Sperimentare e quindi controllare i risultati. Verrà visualizzata una risposta 63. Per vedere una possibile risposta, visualizzare il codice completo in GitHub.

È stata completata l'esercitazione "Cicli e rami".

È possibile continuare con l'esercitazione Matrici e raccolte nel proprio ambiente di sviluppo.

Per altre informazioni su questi concetti, vedere gli articoli seguenti:

• Istruzioni di selezione
• Istruzioni di iterazione