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. Si scrive codice C# e vengono visualizzati i risultati della compilazione e dell'esecuzione. L'esercitazione contiene una serie di lezioni che esplorano i costrutti di diramazione e ciclo in C#. Queste lezioni illustrano i concetti fondamentali del linguaggio C#.

Suggerimento

Quando un blocco di frammenti di codice include il pulsante "Esegui", il pulsante apre la finestra interattiva o sostituisce il codice esistente nella finestra interattiva. Quando il frammento di codice non include un pulsante "Esegui", è possibile copiare il codice e aggiungerlo alla finestra interattiva corrente.

Eseguire il codice seguente nella finestra interattiva. Seleziona Esegui:

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

Modificare la dichiarazione di b in modo che la somma sia minore di 10:

int b = 3;

Selezionare di nuovo il pulsante Esegui . Poiché la risposta è minore di 10, non viene stampato nulla. La condizione che stai testando è falsa. Non è necessario eseguire codice perché è stato scritto solo uno dei rami possibili per un'istruzione if: il ramo true.

Suggerimento

Durante l'esplorazione di C# (o qualsiasi linguaggio di programmazione), si commettono errori durante la scrittura di codice. Il compilatore individua tali errori e li segnala all'utente. Quando l'output contiene messaggi di errore, esaminare attentamente il codice di esempio e il codice nella finestra interattiva per vedere cosa correggere. Questo esercizio consente di apprendere la struttura del codice C#.

Questo primo esempio mostra la potenza dei tipi if e booleani. Un booleano è una variabile che può avere uno dei due valori seguenti: 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 il if. In caso contrario, viene ignorato.

Questo processo di controllo delle condizioni e dell'esecuzione di istruzioni basate su tali condizioni è potente. Esaminiamo di più.

Fare in modo che le istruzioni if ed else funzionino insieme

Per eseguire codice diverso nei rami true e false, creare un ramo else che viene eseguito quando la condizione è false. Provare il 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");

L'istruzione che segue la parola chiave else viene eseguita solo quando la condizione sottoposta a test è false. La combinazione di if e else con condizioni booleane offre tutta la potenza necessaria.

Importante

L'indentazione delle istruzioni if e else è pensata per i lettori umani. Il linguaggio C# non considera il rientro o lo spazio bianco come significativo. L'istruzione che segue la parola chiave if o else viene eseguita in base alla condizione. Tutti gli esempi di questa esercitazione seguono una pratica comune per indentare le righe in base al flusso di controllo delle istruzioni.

Poiché il rientro non è significativo, è necessario usare { e } per indicare quando si vuole che più di un'istruzione faccia 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 è identico a quello creato. Provaci.

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

Nel resto di questa esercitazione, tutti gli esempi di codice includono le parentesi graffe, seguendo le procedure accettate.

È possibile testare condizioni più complesse:

int a = 5;
int b = 3;
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 di == verifica l'uguaglianza . L'uso di == distingue il test per verificare l'uguaglianza dall'assegnazione, che hai visto in a = 5.

Il && rappresenta "e". Significa che entrambe le condizioni devono essere "true" per eseguire l'istruzione nel ramo "true". Questi esempi mostrano anche che è possibile avere più istruzioni in ciascun ramo condizionale, purché siano racchiuse tra { e }.

È anche possibile usare || per rappresentare "o":

if ((a + b + c > 10) || (a == b))

Modificare i valori di a, be c e passare da && a || per esplorare. Si ottiene una maggiore comprensione del funzionamento degli operatori && e ||.

Usare cicli per ripetere le operazioni

Un altro concetto importante per creare programmi di grandi dimensioni è cicli. Si usano cicli per ripetere le istruzioni che si desidera eseguire più volte. Provare questo codice nella finestra interattiva:

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

L'istruzione while controlla una condizione ed esegue l'istruzione che segue il while. Ripete il controllo della condizione e l'esecuzione di tali istruzioni finché la condizione non è falsa.

In questo esempio è presente un altro nuovo operatore. Il ++ dopo la variabile counter è l'operatore di incremento . Aggiunge 1 al valore del contatore e archivia tale valore nella variabile del contatore.

Importante

Assicurarsi che, durante l'esecuzione del codice, la condizione del ciclo while diventi false. In caso contrario, si crea un ciclo infinito in cui il programma non termina mai. Non lo dimostriamo, perché il motore che esegue il tuo codice va in timeout e quindi non vedi alcun output dal tuo programma.

Il ciclo while verifica la condizione prima di eseguire il codice che segue il while. Il ciclo do ... while esegue prima il codice e quindi controlla la condizione. L'aspetto è simile al seguente:

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

Questo ciclo do e il ciclo di while precedente funzionano allo stesso modo.

Passiamo a un ultimo ciclo di istruzioni.

Lavorare con il ciclo for

Un'altra istruzione di ciclo comune visualizzata nel codice C# è il ciclo for. Provare questo codice nella finestra interattiva:

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

Il ciclo for precedente funziona allo stesso modo del ciclo while e del ciclo do già usato. L'istruzione for include tre parti che controllano il funzionamento:

• La prima parte è la per l'inizializzatore: int counter = 0; dichiara che counter è la variabile di ciclo e imposta il relativo valore iniziale su 0.
• La parte centrale è la per la condizione: counter < 10 dichiara che questo ciclo for continua a essere eseguito purché il valore del contatore sia minore di 10.
• La parte finale è la per l'iteratore: counter++ specifica come modificare la variabile del ciclo dopo l'esecuzione del blocco dopo l'istruzione for. In questo caso, specifica che counter incrementa di 1 ogni volta che viene eseguito il blocco.

Prova queste condizioni da solo. Provare ognuna delle modifiche seguenti:

• Modificare l'inizializzatore in modo che inizi con un valore diverso.
• Modificare la condizione in modo che si arresti a un valore diverso.

Al termine, si passerà a scrivere codice manualmente per usare ciò che si è appreso.

In questo tutorial non è trattata un'altra istruzione di ciclo: l'istruzione foreach. L'istruzione foreach ripete l'istruzione per ogni elemento in una sequenza di elementi. Viene usato più spesso con le raccolte . Questa esercitazione è illustrata nell'esercitazione successiva.

Creazione di cicli annidati

Un ciclo while, 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 ciclo for 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})");
    }
}

Si noterà che il ciclo esterno viene incrementato una volta per ogni esecuzione completa del ciclo interno. Invertite l'annidamento di righe e colonne e osservate le modifiche voi stessi.

Combinare rami e cicli

Dopo aver visto l'istruzione if e i costrutti di ciclo nel linguaggio C#, vedere se è possibile scrivere codice C# per trovare la somma di tutti i numeri interi da 1 a 20 che sono divisibile per 3. Ecco alcuni suggerimenti:

• L'operatore % fornisce il resto di un'operazione di divisione.
• L'istruzione if stabilisce la condizione per determinare se un numero deve essere incluso nella somma.
• Il ciclo for consente di ripetere una serie di passaggi per tutti i numeri da 1 a 20.

Provalo da solo. Quindi controlla come hai fatto. Come suggerimento, si dovrebbe ottenere 63 come risposta.

Sei venuto con qualcosa di simile a questo?

::code language="csharp" interactive="try-dotnet-method" source="./snippets/BranchesAndLoops/Program.cs" id="Challenge":::

Hai completato l'esercitazione interattiva "rami e cicli". È possibile selezionare il collegamento raccolta di elenchi per avviare l'esercitazione interattiva successiva, oppure visitare il sito .NET per scaricare l'SDK .NET, creare un progetto sul proprio computer e continuare a scrivere codice. La sezione "Passaggi successivi" ti guida verso questi tutorial.

Per altre informazioni su questi concetti, vedere questi articoli:

• istruzioni di selezione
• istruzioni di iterazione