Esercizio - Creare una logica decisionale con istruzioni if

19 minuti

La maggior parte delle applicazioni include un numero elevato di percorsi di esecuzione. Ad esempio, un'applicazione può implementare percorsi di esecuzione diversi in base all'opzione di menu selezionata da un utente. Gli sviluppatori fanno riferimento al codice che implementa percorsi di esecuzione diversi come rami di codice.

L'istruzione di diramazione del codice più usata è l'istruzione if. L'istruzione if si basa su un'espressione booleana racchiusa in un set di parentesi. Se l'espressione è vera, viene eseguito il codice che segue l'istruzione if. In caso contrario, il runtime .NET ignora il codice e non lo esegue.

In questo esercizio si proverà a scrivere istruzioni if creando un gioco. Prima di tutto si definiranno le regole del gioco, quindi le si implementeranno nel codice.

Si userà il metodo Random.Next() per simulare il lancio di tre dadi a sei facce. Si valuteranno i valori ottenuti per calcolare il punteggio. Se il punteggio è maggiore di un totale arbitrario, verrà visualizzato il messaggio che l'utente ha vinto. Se il punteggio è inferiore al limite, verrà visualizzato il messaggio che l'utente ha perso.

Se uno qualsiasi dei due dadi che lanci risulta avere lo stesso valore, ottieni due punti extra per aver lanciato un doppio.
Se tutti e tre i dadi lanciati hanno lo stesso valore, l'utente ottiene sei punti bonus per aver ottenuto tre volte lo stesso punteggio.
Se la somma dei tre dadi lanciati, più eventuali punti bonus, è maggiore o uguale a 15, l'utente vince. In caso contrario, perde.

Si affineranno le regole man mano che si apprenderanno altre informazioni sull'istruzione if.

Importante

Questo esercizio fa ampio uso della classe System.Random. È possibile fare riferimento al modulo di Microsoft Learn denominato "Chiamare i metodi dalla libreria di classi .NET usando C#" se è necessario un aggiornamento sul funzionamento di Random.Next().

Prepara l'ambiente di scrittura del codice

Questo modulo include attività che guidano l'utente attraverso il processo di compilazione ed esecuzione di un codice di esempio. È consigliabile completare queste attività usando Visual Studio Code come ambiente di sviluppo. L'uso di Visual Studio Code per queste attività consente di acquisire familiarità nella scrittura e nell'esecuzione del codice in un ambiente di sviluppo usato da professionisti di tutto il mondo.

Apri Visual Studio Code.

Per aprire Visual Studio Code, è possibile usare il menu Start di Windows (o una risorsa equivalente per un altro sistema operativo).
In Visual Studio Code selezionare Apri cartella dal menu File.
Nella finestra di dialogo Apri cartella passare alla cartella Desktop di Windows.

Se si usa un percorso di cartella diverso per conservare i progetti di codice, è possibile usare tale percorso. Per questa formazione, è importante che il luogo sia facile da individuare e ricordare.
Nella finestra di dialogo Apri cartella, selezionare Seleziona cartella.

Se viene visualizzata una finestra di dialogo di sicurezza che chiede se si considerano attendibili gli autori, selezionare Sì.
Nel menu Terminale di Visual Studio Code, selezionare Nuovo terminale.

Si noti che un prompt dei comandi nel pannello Terminale visualizza il percorso della cartella corrente. Ad esempio:
```
C:\Users\someuser\Desktop>
```
Nota

Se si usa il proprio PC anziché un ambiente sandbox o ospitato e sono stati completati altri moduli di Microsoft Learn in questa serie C#, potrebbe essere già stata creata una cartella di progetto per gli esempi di codice. In tal caso, è possibile ignorare il passaggio successivo, usato per creare un'app console nella cartella TestProject.
Al prompt dei comandi del terminale, per creare una nuova applicazione console in una cartella specificata, immettere il prompt seguente:
```
dotnet new console -o ./CsharpProjects/TestProject
```
Questo comando dell'interfaccia della riga di comando .NET usa un modello di programma .NET per creare un nuovo progetto di applicazione console C# nel percorso della cartella specificato. Il comando crea le cartelle CsharpProjects e TestProject e usa TestProject come nome del file .csproj.

Se viene visualizzato un messaggio che indica che i file esistono già, continuare con i passaggi successivi. I file di progetto esistenti verranno riutilizzati.
Nella visualizzazione EXPLORER espandere la cartella CsharpProjects .

Verranno visualizzati la cartella TestProject e due file, un file di programma C# denominato Program.cs e un file di progetto C# denominato TestProject.csproj.
In Visual Studio Code selezionare Apri cartella dal menu File.
Nella finestra di dialogo Apri cartella selezionare la cartella CsharpProjects e quindi selezionare Seleziona cartella.
Nella visualizzazione EXPLORER espandere la cartella TestProject e quindi selezionare Program.cs.
Eliminare le righe di codice esistenti.

Questo progetto console C# verrà usato per creare, compilare ed eseguire esempi di codice durante questo modulo.
Chiudere il pannello Terminale.

Scrivere codice che genera tre numeri casuali e li visualizza nell'output

Assicurarsi che in Visual Studio Code sia aperto un file Program.cs vuoto.

Per creare il codice iniziale per questo esercizio, immettere quanto segue:

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

Prenditi un momento per esaminare il codice immesso.

Per iniziare, si crea una nuova istanza della classe System.Random e si archivia un riferimento all'oggetto in una variabile denominata dice. Chiamare quindi per tre volte il metodo Random.Next() sull'oggetto dice, specificando i limiti inferiori e superiori per limitare i valori possibili tra 1 e 6 (il limite superiore è esclusivo). I tre numeri casuali vengono salvati rispettivamente nelle variabili roll1, roll2 e roll3.

Successivamente, si sommano i tre dadi lanciati e si salva il valore in una variabile integer denominata total.

Infine, si usa il metodo WriteLine() per visualizzare i tre valori usando l'interpolazione di stringhe.

Quando si esegue il codice, verrà visualizzato il messaggio seguente (i numeri saranno diversi).
```
Dice roll: 4 + 5 + 2 = 11
```
Questa prima attività è un'attività di configurazione. A questo punto è possibile aggiungere la logica decisionale al codice per rendere il gioco più interessante.

Aggiungere un'istruzione if per visualizzare messaggi diversi in base al valore della variabile total

Nell'editor di Visual Studio Code posizionare il cursore nella parte inferiore del file di codice e quindi creare una riga di codice vuota.
Per creare la prima funzionalità di gioco, immettere le istruzioni if seguenti.
```
if (total > 14)
{
    Console.WriteLine("You win!");
}

if (total < 15)
{
    Console.WriteLine("Sorry, you lose.");
}
```
Queste due istruzioni if vengono usate per gestire gli scenari di vincita e perdita. Soffermarsi qualche istante a esaminare la prima istruzione if.

Si noti che l'istruzione if è costituita da tre parti:
- Parola chiave if
- Espressione booleana tra parentesi ()
- Blocco di codice definito da parentesi graffe { }
In fase di esecuzione, viene valutata l'espressione booleana total > 14. Se l'istruzione è true, ovvero se il valore di total è maggiore di 14, il flusso di esecuzione continuerà nel codice definito nel blocco di codice. In altre parole, verrà eseguito il codice tra parentesi graffe.

Tuttavia, se l'espressione booleana è false, ovvero il valore di total non è maggiore di 14, il flusso di esecuzione passerà oltre il blocco di codice. In altre parole, non verrà eseguito il codice tra parentesi graffe.

Infine, la seconda istruzione if controlla il messaggio se l'utente perde. Nell'unità successiva verrà usata una variante dell'istruzione if per abbreviare queste due istruzioni in un'unica istruzione che esprima più chiaramente la finalità.

Che cos'è un'espressione booleana?

Un'espressione booleana è un codice che restituisce un valore booleano, true o false. Le espressioni booleane più semplici sono semplicemente i valori true e false. In alternativa, un'espressione booleana potrebbe essere il risultato di un metodo che restituisce il valore true o false. Ecco un semplice esempio di codice che usa il metodo string.Contains() per valutare se una stringa contiene un'altra stringa.

string message = "The quick brown fox jumps over the lazy dog.";
bool result = message.Contains("dog");
Console.WriteLine(result);

if (message.Contains("fox"))
{
    Console.WriteLine("What does the fox say?");
}

Poiché message.Contains("fox") restituisce un valore true o false, si qualifica come espressione booleana, che può essere usata in un'istruzione if.

È possibile creare altre espressioni booleane semplici usando gli operatori per confrontare due valori. Gli operatori includono:

==, operatore "uguale a" per verificare l'uguaglianza
>, operatore "maggiore di" per verificare se il valore a sinistra è maggiore di quello a destra
<, operatore "minore di" per verificare se il valore a sinistra è minore di quello a destra
>=, operatore "maggiore o uguale a"
<=, operatore "minore o uguale a"
e così via…

Nota

La serie di training C# in Microsoft Learn dedica un intero modulo alle espressioni booleane. Per creare un'espressione booleana si possono usare molti operatori. In questo modulo verranno illustrati solo alcuni dei principali. Per altre informazioni sulle espressioni booleane, vedere il modulo di Microsoft Learn denominato "Valutare le espressioni booleane per prendere decisioni in C#".

In questo esempio è stata valutata l'espressione booleana total > 14. Tuttavia, la scelta sarebbe potuta ricadere sull'espressione booleana total >= 15, dal momento che in questo caso si equivalgono. Dato che le regole del gioco specificano che "se la somma dei tre dadi, più eventuali bonus, è uguale o maggiore di 15, si vince", probabilmente si dovrebbe implementare l'espressione >= 15. Questa modifica verrà apportata nel passaggio successivo dell'esercizio.

Che cos'è un blocco di codice?

Un blocco di codice è una raccolta di una o più righe di codice delimitate dalle parentesi graffe di apertura e chiusura { }. Rappresenta un'unità completa di codice con un unico scopo nel sistema software. In questo caso, in fase di esecuzione, tutte le righe di codice nel blocco di codice vengono eseguite se l'espressione booleana è true. Al contrario, se l'espressione booleana è false, tutte le righe di codice nel blocco di codice vengono ignorate.

Tenere anche presente che i blocchi di codice possono contenere altri blocchi di codice. Infatti, è comune che un blocco di codice sia "annidato" all'interno di un altro blocco di codice nelle applicazioni. Si inizierà ad annidare i propri blocchi di codice più avanti in questo modulo quando si crea un'istruzione if all'interno del blocco di codice di un'altra istruzione.

Nota

La serie di training C# in Microsoft Learn dedica un intero modulo alla comprensione dei blocchi di codice. I blocchi di codice sono fondamentali per comprendere l'organizzazione e la struttura del codice e definiscono i limiti degli ambiti delle variabili. Per altre informazioni sui blocchi di codice, vedere il modulo "Controllare l'ambito delle variabili e la logica usando blocchi di codice in C#".

Aggiungere un'altra istruzione if per implementare il bonus per aver ottenuto due volte lo stesso punteggio

A questo punto, è possibile implementare la regola: "Se qualsiasi coppia di dadi che lanci ha lo stesso valore, si ottengono due punti bonus per aver ottenuto un doppio". Modificare il codice del passaggio precedente in modo che corrisponda al listato di codice seguente:

Nell'editor di Visual Studio Code posizionare il cursore sulla riga di codice vuota sopra la prima istruzione if.
Per creare la funzionalità di gioco dello stesso punteggio ottenuto due volte, immettere l'istruzione if seguente.
```
if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3))
{
    Console.WriteLine("You rolled doubles! +2 bonus to total!");
    total += 2;
}
```
Sono state combinate tre espressioni booleane per crearne una composta in una sola riga di codice. Questa operazione viene talvolta definita condizione composta. È presente un set esterno di parentesi che combina tre set interni di parentesi separati da due caratteri barra verticale.

I caratteri doppia barra verticale || sono l'operatore OR logico, che sostanzialmente indica che "l'espressione a sinistra O l'espressione a destra deve essere true affinché l'intera espressione booleana sia true". Se entrambe le espressioni booleane sono false, l'intera espressione booleana è false. Vengono usati due operatori OR logici in modo che sia possibile estendere la valutazione a una terza espressione booleana.

Prima di tutto, si valuta (roll1 == roll2). Se è vero, allora l'intera espressione è vera. Se è false, si valuta (roll2 == roll3). Se è vero, allora l'intera espressione è vera. Se è false, si valuta (roll1 == roll3). Se è vero, allora l'intera espressione è vera. Se è falso, l'intera espressione è falsa.

Se l'espressione booleana composta è true, viene eseguito il blocco di codice seguente. Questa volta sono presenti due righe di codice. La prima riga di codice visualizza un messaggio per l'utente. La seconda riga di codice incrementa il valore di total di 2.
Per migliorare la leggibilità del codice, aggiornare la seconda istruzione if come segue:
```
if (total >= 15)
```
Si noti che ora si usa l'operatore >= nell'espressione usata per valutare un lancio vincente. L'operatore >= significa "maggiore o uguale a". Di conseguenza, è possibile confrontare total con un valore di 15 anziché 14. Con queste modifiche, l'espressione che usi per valutare un lancio vincente ora somiglia all'espressione che valuti per un lancio perdente. Ciò dovrebbe aiutare a semplificare la comprensione del codice (più leggibile). Poiché si tratta di valori integer, la nuova espressione (total >= 15) funzionerà in modo identico a quella scritta in precedenza (total > 14).

Dedicare qualche minuto alla revisione del codice.

Il codice dovrebbe corrispondere al seguente:

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3))
{
    Console.WriteLine("You rolled doubles! +2 bonus to total!");
    total += 2;
}

if (total >= 15)
{
    Console.WriteLine("You win!");
}

if (total < 15)
{
    Console.WriteLine("Sorry, you lose.");
}

Si noti l'allineamento migliorato tra le espressioni usate per valutare i lanci vincenti e quelli perdenti.

Aggiungere un'altra istruzione if per implementare il bonus per aver ottenuto tre volte lo stesso punteggio

È possibile implementare la regola: "Se tutti e tre i dadi lanciati hanno lo stesso valore, si ottengono sei punti bonus per il lancio di tre dadi". Modificare il codice dei passaggi precedenti in modo che corrisponda all'elenco codici seguente:

Nell'editor di Visual Studio Code, crea una riga di codice vuota sotto il blocco di codice dell'istruzione "doubles" if.
Per creare la funzionalità di gioco dello stesso punteggio ottenuto tre volte, immettere l'istruzione if seguente.
```
if ((roll1 == roll2) && (roll2 == roll3)) 
{
    Console.WriteLine("You rolled triples! +6 bonus to total!");
    total += 6;
}
```
Sono state combinate due espressioni booleane per crearne una composta in una sola riga di codice. È presente un set di parentesi esterne che racchiude due set di parentesi interne separati da due caratteri ampersand.

I caratteri doppia e commerciale && sono l'operatore AND logico, che sostanzialmente indica che "solo se entrambe le espressioni sono true, l'intera espressione è true". In questo caso, se roll1 è uguale a roll2 e roll2 è uguale a roll3, per deduzione roll1 deve essere uguale a roll3 e l'utente ha ottenuto tre volte lo stesso punteggio.
Fare clic su Salva nel menu File di Visual Studio Code.

Dedicare qualche minuto alla revisione del codice.

Verificare che il codice corrisponda al seguente:

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;

Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3))
{
    Console.WriteLine("You rolled doubles! +2 bonus to total!");
    total += 2;
}

if ((roll1 == roll2) && (roll2 == roll3)) 
{
    Console.WriteLine("You rolled triples! +6 bonus to total!");
    total += 6;
}

if (total >= 15)
{
    Console.WriteLine("You win!");
}

if (total < 15)
{
    Console.WriteLine("Sorry, you lose.");
}

Nella visualizzazione EXPLORER, per aprire un terminale nel percorso della cartella TestProject, fare clic con il pulsante destro del mouse su TestProject e quindi scegliere Apri nel terminale integrato.

Verrà aperto un pannello del terminale con un prompt dei comandi che indica che il terminale è aperto al percorso della cartella TestProject.
Nel prompt dei comandi del terminale, digitare dotnet run per eseguire il codice, quindi premere INVIO.

Nota

Se viene visualizzato un messaggio riportante: “Non è stato possibile trovare un progetto da eseguire”, assicurarsi che il prompt dei comandi del terminale visualizzi il percorso previsto della cartella TestProject. Ad esempio: C:\Users\someuser\Desktop\csharpprojects\TestProject>

Verrà visualizzato un output simile a uno dei risultati seguenti:
```
Dice roll: 3 + 6 + 1 = 10
Sorry, you lose.
```
Oppure, così:
```
Dice roll: 1 + 4 + 4 = 9
You rolled doubles! +2 bonus to total!
Sorry, you lose.
```
Oppure, così:
```
Dice roll: 5 + 6 + 4 = 15
You win!
```
Oppure, se si è fortunati, si vedrà quanto segue:
```
Dice roll: 6 + 6 + 6 = 18
You rolled doubles! +2 bonus to total!
You rolled triples! +6 bonus to total!
You win!
```
Ma aspetta, dovresti davvero ricompensare il giocatore con sia il triplo bonus che il doppio bonus? Dopo tutto, un lancio in cui si ottiene tre volte lo stesso punteggio implica che è stato ottenuto anche due volte lo stesso punteggio. Idealmente, i bonus non dovrebbero cumularsi. Dovrebbero esserci due condizioni di bonus separate. Si tratta di un bug nella logica che dovrà essere corretto.

Problemi nella logica e opportunità di migliorare il codice

Benché questo sia un buon inizio, e siano stati approfonditi gli argomenti relativi a istruzione if, espressioni booleane, blocchi di codice, operatori logici OR e AND e così via, ci sono ancora molte opportunità di miglioramento. Si eseguirà questa operazione nella prossima unità.

Riepilogo

Usare un'istruzione if per ramificare la logica del codice. L'istruzione decisionale if eseguirà il codice nel relativo blocco di codice se la relativa espressione booleana è uguale a true. In caso contrario, il runtime ignorerà il blocco di codice e continuerà alla riga di codice successiva dopo il blocco di codice.
Un'espressione booleana è un'espressione che restituisce un valore booleano.
Gli operatori booleani confrontano i due valori a sinistra e a destra per verificare l'uguaglianza, il confronto e altro ancora.
Un blocco di codice è definito da parentesi graffe { }. Raccoglie le righe di codice che devono essere considerate come una singola unità.
L'operatore AND logico && aggrega due espressioni in modo che entrambe le sottoespressioni debbano essere true affinché l'intera espressione sia true.
L'operatore OR logico || aggrega due espressioni in modo che se una delle sottoespressioni è true, l'intera espressione è true.

Commenti e suggerimenti

Questa pagina è stata utile?

Esercizio - Creare una logica decisionale con istruzioni if

Verificare le conoscenze

Commenti e suggerimenti