1️⃣ Cos'è un ciclo foreach

Il ciclo foreach in C# è uno strumento di iterazione usato per scorrere gli elementi di una collezione o di un array in modo semplice e leggibile. Questo ciclo permette di accedere a ciascun elemento di una collezione senza dover usare un indice o gestire manualmente la condizione di uscita, come invece accade nei cicli for tradizionali.

Sintassi di base:

foreach (tipo elemento in collezione)
    {
        // Codice che utilizza l'elemento corrente
    }

• tipo: Il tipo degli elementi della collezione (come int, string, var, ecc.).

• elemento: Il nome della variabile che rappresenta l'elemento corrente in ciascuna iterazione.

• collezione: La collezione o array da scorrere (come List, Array, Dictionary, ecc.).

Esempio di base con un array:

string[] colori = { "Rosso", "Verde", "Blu" };
    
    foreach (string colore in colori)
    {
        Console.WriteLine(colore);
    }
    
    /* Output:
    Rosso
    Verde
    Blu
    */

2️⃣ Perché usare foreach

Il ciclo foreach è particolarmente utile quando:

• Si vuole accedere a ciascun elemento di una collezione senza modificare la collezione stessa.

• Si preferisce scrivere codice più chiaro e leggibile.

• Si vuole evitare la gestione manuale degli indici.

Rispetto ad altri cicli (for e while), foreach rende il codice meno soggetto a errori perché non richiede di sapere la lunghezza della collezione o di incrementare un contatore.

3️⃣ foreach con diversi tipi di collezioni

In C#, foreach può essere usato su qualsiasi collezione che implementi l’interfaccia IEnumerable o IEnumerable<T>.

Esempio con una lista (List<T>):

List<int> numeri = new List<int> { 1, 2, 3, 4, 5 };
    
    foreach (int numero in numeri)
    {
        Console.WriteLine(numero);
    }
    
    /* Output:
    1
    2
    3
    4
    5
    */

Esempio con un dizionario (Dictionary<TKey, TValue>):

Quando si scorre un dizionario, ogni elemento è una coppia KeyValuePair<TKey, TValue>:

Dictionary<string, int> età = new Dictionary<string, int>
    {
        { "Alice", 30 },
        { "Bob", 25 },
        { "Charlie", 35 }
    };
    
    foreach (KeyValuePair<string, int> persona in età)
    {
        Console.WriteLine($"{persona.Key} ha {persona.Value} anni.");
    }
    
    /* Output:
    Alice ha 30 anni.
    Bob ha 25 anni.
    Charlie ha 35 anni.
    */

Esempio con un array bidimensionale

Il foreach può essere usato per iterare sugli elementi di un array bidimensionale, anche se in questo caso la struttura interna non è accessibile come con un for:

int[,] matrice = { {1, 2}, {3, 4}, {5, 6} };
    
    foreach (int elemento in matrice)
    {
        Console.WriteLine(elemento);
    }
    
    /* Output
    1
    2
    3
    4
    5
    6
    */

4️⃣ Limitazioni di foreach

Sebbene foreach sia utile, ha alcune limitazioni:

• Accesso solo in lettura: Non si possono modificare gli elementi della collezione direttamente. Per modificare gli elementi, bisogna usare un ciclo for o accedere direttamente agli elementi tramite l’indice.

• Modifiche alla collezione: Durante l'iterazione, non è possibile aggiungere o rimuovere elementi dalla collezione, poiché genera un'eccezione InvalidOperationException.

Ad esempio, questo codice genera un errore:

List<int> numeri = new List<int> { 1, 2, 3 };
    
    foreach (int numero in numeri)
    {
        if (numero == 2)
        {
            numeri.Remove(numero);  // Questo genererà un'eccezione
        }
    }

Per modificare la collezione, si può usare un ciclo for inverso o un ciclo for standard per evitare eccezioni.

5️⃣ foreach e LINQ

In combinazione con le espressioni LINQ (Language-Integrated Query), foreach diventa ancora più potente. Possiamo, ad esempio, filtrare gli elementi in una collezione prima di iterare su di essi.

Esempio di foreach con LINQ:

List<int> numeri = new List<int> { 1, 2, 3, 4, 5 };
    
    var numeriPari = numeri.Where(n => n % 2 == 0);
    
    foreach (int numero in numeriPari)
    {
        Console.WriteLine(numero);
    }
    
    /* Output:
    2
    4
    */

6️⃣ Esempi pratici

Iterare su una lista di oggetti personalizzati:

public class Studente
    {
        public string Nome { get; set; }
        public int Età { get; set; }
    }
    
    List<Studente> studenti = new List<Studente>
    {
        new Studente { Nome = "Alice", Età = 20 },
        new Studente { Nome = "Bob", Età = 22 },
        new Studente { Nome = "Charlie", Età = 21 }
    };
    
    foreach (Studente studente in studenti)
    {
        Console.WriteLine($"{studente.Nome} ha {studente.Età} anni.");
    }
    
    /* Output:
    Alice ha 20 anni.
    Bob ha 22 anni.
    Charlie ha 21 anni.
    */

Iterare su una stringa:

In C#, anche una stringa è una collezione di caratteri (char), quindi è possibile usare foreach per accedere a ciascun carattere:

string parola = "CSharp";
    
    foreach (char lettera in parola)
    {
        Console.Write(lettera + " ");
    }
    
    /* Output:
    C S h a r p
    */

📑 Esercizi

Vi propongo, per iniziare a familiarizzare con questa lezione, di provare a riscrivere alcuni cicli for che avete già scritto usando il foreach dove possibile.