Esercizio - Creare cicli di iterazione do e while

10 minuti

In superficie, le istruzioni do-while e while sono ulteriori istruzioni di iterazione che consentono di scorrere un blocco di codice e di conseguenza modificare il flusso di esecuzione del codice. Tuttavia, una volta esaminato il funzionamento di ogni istruzione, è possibile identificare meglio le sfumature di ogni istruzione di iterazione e quando usarle.

Che cos'è l'istruzione do-while?

L'istruzione do-while esegue un'istruzione o un blocco di istruzioni mentre un'espressione booleana specificata restituisce true. Poiché tale espressione viene valutata dopo ogni esecuzione del ciclo, un ciclo do-while viene eseguito una o più volte.

do
{
    // This code executes at least one time
} while (true);

Il flusso dell'esecuzione inizia all'interno della parentesi graffa. Il codice viene eseguito almeno una volta, quindi viene valutata l'espressione booleana accanto alla while parola chiave . Se l'espressione booleana restituisce true, il blocco di codice viene eseguito di nuovo.

Codificando staticamente l'espressione booleana in true, abbiamo creato un ciclo infinito, cioè un ciclo che non terminerà mai, almeno non come è attualmente scritto. Sarebbe necessario un modo per interrompere il ciclo all'interno del blocco di codice. Verranno illustrati i criteri di uscita di un do-while in un po'.

A questo punto è possibile preparare l'ambiente di codifica e iniziare l'esame degli esempi di codice che implementano un'istruzione do-while .

Prepara l'ambiente di scrittura del codice

Questo modulo include attività pratiche che illustrano il processo di compilazione ed esecuzione del codice dimostrativo. È 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).
Scegliere Apri cartella dal menu File di Visual Studio Code.
Nella finestra di dialogo Apri cartella passare alla cartella Desktop di Windows.

Se hai una cartella diversa dove conservi i progetti di codice, puoi usare quella cartella. 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. Per esempio:
```
C:\Users\someuser\Desktop>
```
Annotazioni

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.
Scegliere Apri cartella dal menu File di Visual Studio Code.
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 un'istruzione do-while per eseguire l'interruzione quando viene generato un determinato numero casuale

Si scriverà il codice che continuerà a generare numeri casuali compresi tra 1 e 10 fino a quando non viene generato il numero 7. Potrebbe essere necessario un'iterazione per ottenere un 7, o potrebbero essere necessarie decine di iterazioni.

Assicurarsi di avere aperto Visual Studio Code e che Program.cs sia visualizzato nel pannello Editor.

Annotazioni

Program.cs deve essere vuoto. In caso contrario, selezionare ed eliminare tutte le righe di codice.

Digitare il codice seguente nel pannello Editor di Visual Studio Code.

Random random = new Random();
int current = 0;

do
{
    current = random.Next(1, 11);
    Console.WriteLine(current);
} while (current != 7);

Nel menu File di Visual Studio Code, selezionare Salva.

Il file Program.cs deve essere salvato prima di compilare o eseguire il codice.
Nel pannello 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.

Si aprirà un pannello Terminale. Il terminale deve includere un prompt dei comandi che mostra che il terminale è aperto sul percorso della cartella TestProject.
Al prompt dei comandi del terminale, per eseguire il codice, digitare dotnet run e quindi premere INVIO.

Annotazioni

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>
Esamina il tuo output.

Poiché i numeri generati sono casuali, i risultati saranno diversi. Tuttavia, il valore 7 sarà l'ultimo numero da stampare, e poiché l'espressione booleana si evaluerà come false quando viene generato il 7, il flusso di esecuzione uscirà dal blocco di codice.
```
2
5
8
2
7
```
Dedicare qualche minuto alla revisione del codice.

Un apprendimento chiave per questa prima attività è che il blocco di codice di un do-while ciclo verrà eseguito almeno una volta. Potrebbe eseguire un'iterazione di un numero elevato di volte ed è improbabile che sappiamo in anticipo quante iterazioni ci saranno.

È anche importante notare che il codice all'interno del blocco di codice influenza se continuare o meno l'iterazione attraverso il blocco di codice. Un blocco di codice che influenza i criteri di uscita è un motivo principale per selezionare un'istruzione do-while o while anziché una delle altre istruzioni di iterazione. Sia che foreachfor si basano su fattori esterni al blocco di codice per determinare il numero di iterazioni del blocco di codice.

Scrivere un'istruzione while che esegue l'iterazione solo mentre un numero casuale è maggiore di un determinato valore

Ora esaminiamo la dichiarazione while.

Usare l'editor di Visual Studio Code per aggiornare il codice nel modo seguente:
```
Random random = new Random();
int current = random.Next(1, 11);

/*
do
{
    current = random.Next(1, 11);
    Console.WriteLine(current);
} while (current != 7);
*/

while (current >= 3)
{
    Console.WriteLine(current);
    current = random.Next(1, 11);
}
Console.WriteLine($"Last number: {current}");
```
Annotazioni

In questo caso, si posiziona la while parola chiave e l'espressione booleana prima del blocco di codice. Ciò modifica il significato del codice e funge da "controllo", che consente al flusso di esecuzione di iniziare solo se l'espressione booleana restituisce true.
Salvare il file di codice e quindi usare Visual Studio Code per eseguire il codice.

Immettere dotnet run dal prompt dei comandi del terminale per eseguire il codice.
Esaminare i valori di output elencati.

Poiché i numeri sono casuali, il codice produrrà una sequenza diversa.
```
9
7
5
Last number: 1
```
Dedicare qualche minuto alla revisione del codice.

Nel codice superiore viene usato random per inizializzare la int variabile denominata current. La riga di codice attiva successiva è l'istruzione while .

La nostra istruzione while eseguirà l'iterazione in base all'espressione (current >= 3) booleana. Non si sa quale valore verrà assegnato a current, ma esistono possibilità che influiscono sul ciclo while :
- Se current viene inizializzato in un valore maggiore o uguale a 3, l'espressione booleana restituirà truee il flusso di esecuzione immetterà il blocco di codice. All'interno del blocco di codice, la prima cosa che si esegue è scrivere il valore di current nella console. Quindi, sempre all'interno del blocco di codice, aggiorniamo il valore di current con un nuovo valore casuale. A questo punto, il controllo torna all'inizio dell'istruzione while in cui viene valutata l'espressione booleana. Questo processo continua fino a quando l'espressione booleana non restituisce false e il flusso di esecuzione si interrompe dal blocco di codice.
- Se current viene inizializzato (all'inizio del codice) su un valore minore di 3, l'espressione booleana restituirà falsee il blocco di codice non verrà mai eseguito.
La riga di codice finale scrive il valore di current nella console. Questo codice viene eseguito sia che il blocco di codice di iterazione sia stato eseguito o meno, ed è l'opportunità di scrivere il valore finale di current sulla console.

Usare l'istruzione continue per eseguire direttamente il passaggio all'espressione booleana

In alcuni casi, si vuole interrompere il resto del blocco di codice e continuare con l'iterazione successiva. È possibile farlo usando l'istruzione continue .

Usare l'editor di Visual Studio Code per aggiornare il codice nel modo seguente:

Random random = new Random();
int current = random.Next(1, 11);

do
{
    current = random.Next(1, 11);

    if (current >= 8) continue;

    Console.WriteLine(current);
} while (current != 7);

/*
while (current >= 3)
{
    Console.WriteLine(current);
    current = random.Next(1, 11);
}
Console.WriteLine($"Last number: {current}");
*/

Dedicare qualche minuto alla revisione del codice.

Si noti che si è tornati a un do-while. L'istruzione do-while garantisce che verrà eseguita almeno un'iterazione del ciclo.

La prima operazione eseguita all'interno del blocco di codice consiste nell'assegnare un nuovo valore casuale a current. Successivamente, si verifica se current è maggiore o uguale a 8. Se questa espressione restituisce true, la parola chiave continue trasferirà il controllo alla fine del blocco di codice e while valuterà (current != 7). Il ciclo continuerà quindi a scorrere finché il valore di current non è uguale a 7.

La chiave di questo passaggio dell'esercizio è la riga di codice contenente la continue parola chiave:
```
if (current >= 8) continue;
```
Poiché il codice che scrive il valore di current nella console si trova dopo il if (current >= 8) continue;, il nostro codice garantisce che un valore di current maggiore o uguale a 8 non verrà mai scritto nella finestra di output.

A questo punto è possibile provare.
Salvare il file di codice e quindi usare Visual Studio Code per eseguire il codice.

Immettere dotnet run dal prompt dei comandi del terminale per eseguire il codice.
Esaminare i valori di output elencati.
```
5
1
6
7
```
È probabile che vengano visualizzati risultati diversi rispetto a quelli visualizzati di seguito. Tuttavia, non verranno visualizzati valori 8 o superiori nella finestra di output prima che l'esecuzione del codice termini con il valore 7.
Si consideri la differenza tra le istruzioni continue e break.

Come illustrato in questo ultimo passaggio, l'istruzione continue trasferisce l'esecuzione alla fine dell'iterazione corrente. Questo comportamento è diverso dal comportamento visualizzato con l'istruzione break . L'istruzione break termina l'iterazione (o switch) e trasferisce il controllo all'istruzione che segue l'istruzione terminata. Se non è presente alcuna istruzione dopo l'istruzione terminata, il controllo viene trasferita alla fine del file o del metodo.

Riepilogo

Ci sono alcune idee importanti da portare via da questa unità:

L'istruzione do-while esegue l'iterazione di un blocco di codice almeno una volta e può continuare a eseguire l'iterazione in base a un'espressione booleana. La valutazione dell'espressione booleana dipende in genere da un valore generato o recuperato all'interno del blocco di codice.
L'istruzione while valuta prima un'espressione booleana e continua a scorrere il blocco di codice purché l'espressione booleana restituisca true.
Parola continue chiave per passare immediatamente all'espressione booleana.

Commenti e suggerimenti

Questa pagina è stata utile?

Esercizio - Creare cicli di iterazione do e while

Verifica delle conoscenze

Commenti e suggerimenti