Esercizio - Creare e configurare i cicli di iterazione

14 minuti

In superficie, l'istruzione for è un'altra istruzione di iterazione che consente di scorrere un blocco di codice e quindi 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 `for`?

L'istruzione for itera attraverso un blocco di codice per un numero specifico di volte. Questo livello di controllo rende l'istruzione for univoca tra le altre istruzioni di iterazione. L'istruzione foreach esegue l'iterazione di un blocco di codice una volta per ogni elemento di una sequenza di dati, ad esempio una matrice o una raccolta. L'istruzione while esegue l'iterazione di un blocco di codice fino a quando non viene soddisfatta una condizione.

Inoltre, l'istruzione for offre un maggiore controllo sul processo di iterazione esponendo le condizioni per l'iterazione.

In questo esercizio si userà l'istruzione for e si apprenderà come controllare la condizione preliminare, la condizione di completamento, il modello di iterazione e altro ancora. Verranno anche illustrati i casi d'uso comuni per l'istruzione for.

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

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 cartellaselezionare Seleziona cartella.

Se viene visualizzata una finestra di dialogo di sicurezza che chiede se si considera attendibile 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 for di base

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.
```
for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
}
```
Questo codice presenta un'istruzione semplice for che scorre il blocco di codice 10 volte, stampando il valore corrente di i.
Scegliere Salva dal menu File di Visual Studio Code.

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>

Dovresti vedere il seguente output.
```
0
1
2
3
4
5
6
7
8
9
```
Prendere un minuto per identificare le sei parti dell'istruzione for.

L'istruzione for include le sei parti seguenti:
1. La parola chiave for.
2. Un set di parentesi che definisce le condizioni di for iterazione. Le parentesi contengono tre parti distinte, separate dall'operatore di fine istruzione, da un punto e virgola.
3. La prima parte definisce e inizializza la variabile iteratore. In questo esempio: int i = 0. Questa sezione viene definita inizializzatore.
4. La seconda parte definisce la condizione di completamento. In questo esempio: i < 10. In altre parole, il runtime continuerà a scorrere il codice nel blocco di codice sotto l'istruzione for mentre i è minore di 10. Quando i diventa uguale a 10, il runtime interrompe l'esecuzione for del blocco di codice dell'istruzione. La documentazione fa riferimento a questa sezione come condizione.
5. La terza parte definisce l'azione da eseguire dopo ogni iterazione. In questo caso, dopo ogni iterazione, i++ incrementerà il valore di i di 1. La documentazione fa riferimento a questa sezione come iteratore.
6. Infine il blocco di codice. Il blocco di codice contiene il codice che verrà eseguito per ogni iterazione. Si noti che il valore di i viene fatto riferimento all'interno del blocco di codice. La documentazione fa riferimento a questa sezione come corpo.
Date le regole per la denominazione delle variabili, è possibile chiedersi se i è un nome valido per la variabile che contiene l'iterazione corrente. In questo caso, i è considerato dalla maggior parte valido. Altre scelte popolari sono x e counter. Il nome j viene usato anche in tali situazioni quando si dispone di un'istruzione esterna for che usa ie deve creare una variabile di iterazione per un'istruzione interna for .

Annotazioni

Tutte e tre le sezioni (inizializzatore, condizione e iteratore) sono facoltative. Tuttavia, in pratica, vengono usate tutte e tre le sezioni.

Modificare le condizioni di iterazione

Come indicato all'inizio, l'istruzione for ha due qualità univoche tra le istruzioni di iterazione.

L'istruzione for deve essere usata quando si conosce il numero di volte in cui è necessario scorrere un blocco di codice in anticipo.
L'istruzione for consente di controllare la modalità di gestione di ogni iterazione.

Come procedere se è necessario eseguire l'iterazione di un blocco di codice, ma si vuole eseguire il conto alla rovescia invece che normalmente?

Usare l'editor di Visual Studio Code per aggiornare il codice nel modo seguente:
```
for (int i = 10; i >= 0; i--)
{
    Console.WriteLine(i);
}
```
Prenditi un momento per esaminare il codice aggiornato.

Modificando le tre parti dell'istruzione for , il comportamento viene modificato.
- Inizializziamo la variabile di iterazione su 10.
- La condizione di completamento viene modificata per uscire dall'istruzione for quando i è minore di 0.
- Il modello dell'iteratore viene modificato in modo da sottrarre 1 da i ogni volta che viene completata un'iterazione.
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.
Si noti che l'output è stato modificato.

Quando si esegue il codice, verrà visualizzato l'output seguente.
```
10
9
8
7
6
5
4
3
2
1
0
```

Sperimentare il modello dell'iteratore

Cosa accade se si desidera ignorare determinati valori nella variabile iteratore?

Usare l'editor di Visual Studio Code per aggiornare il codice nel modo seguente:
```
for (int i = 0; i < 10; i += 3)
{
    Console.WriteLine(i);
}
```
Prenditi un momento per esaminare il codice aggiornato.

Anziché incrementare o decrementare il valore della variabile iteratore da 1, viene usato i += 3 per ignorare due valori dopo ogni iterazione.
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.
Si noti che l'output è stato modificato.

Quando si esegue il codice, verrà visualizzato l'output seguente.
```
0
3
6
9
```
Certo, non si farà questo tipo di cose spesso, ma speriamo che tu possa apprezzare che hai un livello di controllo dettagliato sulle iterazioni qualora ne avessi bisogno.

Usare la parola chiave break per interrompere l'istruzione di iterazione

Cosa accade se è necessario uscire prematuramente dal ciclo di iterazione in base a qualche condizione? È possibile usare la break parola chiave .

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

for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
    if (i == 7) break;
}

Prenditi un minuto per esaminare l'uso della parola chiave break nel tuo codice aggiornato.

La parola chiave break è stata presentata nel modulo "Diramare il flusso di codice usando il costrutto switch-case in C#". Come si è scoperto, è possibile usare la break parola chiave anche per uscire dalle istruzioni di iterazione.
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.
Si noti che l'output è stato modificato.

Quando si esegue il codice, verrà visualizzato l'output seguente.
```
0
1
2
3
4
5
6
7
```

Scorrere ogni elemento di una matrice

Un utilizzo comune per l'istruzione for consiste nell'eseguire l'iterazione di una matrice di elementi, soprattutto se è necessario avere un certo controllo sul modo in cui si verifica l'iterazione. Mentre foreach esegue l'iterazione di ogni elemento della matrice, l'istruzione for può essere modificata e personalizzata in base alle esigenze.

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

string[] names = { "Alex", "Eddie", "David", "Michael" };
for (int i = names.Length - 1; i >= 0; i--)
{
    Console.WriteLine(names[i]);
}

Prenditi un momento per esaminare il codice aggiornato.

Nota che abbiamo creato un array di stringhe chiamato names che contiene quattro nomi.

Si noti quindi che si usa la Array.Length proprietà per ottenere il numero di elementi nella matrice e che si sta usando questo valore per inizializzare la variabile iteratore (int i = names.Length - 1). Viene sottratto 1 dal valore perché il numero di indice per gli elementi della matrice è in base zero (i numeri di indice dei quattro elementi sono 0-3).

Infine, notate che abbiamo scelto di iterare attraverso l'array al contrario, cosa che non possiamo fare con l'istruzione foreach. Viene usato il valore della variabile di iterazione all'interno del blocco di codice per specificare il numero di indice degli elementi della matrice (names[i]).
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.
Si noti che gli elementi della matrice sono elencati in ordine inverso (come previsto).

Quando si esegue il codice, verrà visualizzato l'output seguente.
```
Michael
David
Eddie
Alex
```
Annotazioni

Si sarebbe potuto iterare attraverso gli elementi dell'array costruendo l'istruzione for come segue: for (int i = 0; i < names.Length; i++).

Esaminare la limitazione dell'istruzione foreach

Cosa accade se si vuole aggiornare un valore nella matrice durante un'iterazione foreach ?

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

string[] names = { "Alex", "Eddie", "David", "Michael" };
foreach (var name in names)
{
    // Can't do this:
    if (name == "David") name = "Sammy";
}

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.
Si noti il messaggio di errore visualizzato.

Se si tenta di compilare ed eseguire questo codice, verrà visualizzata un'eccezione.
```
Cannot assign to name because it is a 'foreach iteration variable'
```
In altre parole, non è possibile riassegnare il valore di name perché fa parte dell'implementazione foreach interna dell'iterazione.

Superamento della limitazione dell'istruzione foreach tramite l'istruzione for

Provare a usare un'istruzione for per modificare il contenuto di una matrice all'interno del blocco di codice di iterazione.

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

string[] names = { "Alex", "Eddie", "David", "Michael" };
for (int i = 0; i < names.Length; i++)
    if (names[i] == "David") names[i] = "Sammy";

foreach (var name in names) Console.WriteLine(name);

Prenditi un momento per esaminare il codice aggiornato.

Si noti che sono state rimosse le parentesi graffe dai blocchi di codice che contengono solo una singola riga di codice. Questa revisione usa la stessa tecnica illustrata nel modulo "Controllare l'ambito e la logica delle variabili usando blocchi di codice in C#". Molti sviluppatori trovano questo stile difficile da leggere, mentre altri preferiscono questo stile abbreviato perché li aiuta a scrivere in modo più conciso ed espressivo. Se si trova difficile leggere questo codice o se non si preferisce questo stile, assicurarsi che le parentesi graffe possano essere sempre usate nei blocchi di codice. Se si vuole, aggiornare il codice nel pannello Editor con il codice seguente:
```
string[] names = { "Alex", "Eddie", "David", "Michael" };

for (int i = 0; i < names.Length; i++)
{
    if (names[i] == "David")
    {
        names[i] = "Sammy";
    }
}

foreach (var name in names)
{
    Console.WriteLine(name);
}
```
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.
Si noti che il codice viene eseguito senza errori e genera l'output desiderato.

Quando si esegue il codice, verrà visualizzato l'output seguente.
```
Alex
Eddie
Sammy
Michael
```
Poiché la matrice non fa parte direttamente dell'implementazione dell'istruzione di iterazione, è possibile modificare i valori all'interno della matrice.

Riepilogo

Di seguito sono riportate alcune delle considerazioni di questa unità:

L'istruzione for di iterazione consente di scorrere un blocco di codice un numero specifico di volte.
L'istruzione for di iterazione consente di controllare ogni aspetto della meccanica dell'iterazione modificando le tre condizioni all'interno delle parentesi: l'inizializzatore, la condizione e l'iteratore.
È comune usare l'istruzione for quando è necessario controllare come eseguire l'iterazione di ogni elemento in una matrice.
Se il blocco di codice contiene solo una riga di codice, è possibile eliminare le parentesi graffe e lo spazio vuoto, se lo si desidera.

Commenti e suggerimenti

Questa pagina è stata utile?

Esercizio - Creare e configurare i cicli di iterazione

Verifica delle conoscenze

Commenti e suggerimenti