Informazioni su come gestire le raccolte dati usando List<T> in C#

Articolo
04/08/2023

Questa esercitazione introduttiva offre un'introduzione al linguaggio C# e i concetti di base relativi alla classe List<T>.

Prerequisiti

L'esercitazione prevede che sia stato configurato un computer per lo sviluppo locale. Vedere Configurare l'ambiente locale per le istruzioni di installazione e una panoramica dello sviluppo di applicazioni in .NET.

Se si preferisce eseguire il codice senza dover configurare un ambiente locale, vedere la versione interattiva in-browser di questa esercitazione.

Esempio di elenco di base

Creare una directory denominata list-tutorial. Impostarla come directory corrente ed eseguire dotnet new console.

Importante

I modelli C# per .NET 6 usano istruzioni di primo livello. L'applicazione potrebbe non corrispondere al codice in questo articolo, se è già stato eseguito l'aggiornamento a .NET 6. Per altre informazioni, vedere l'articolo sui nuovi modelli C# genera istruzioni di primo livello

.NET 6 SDK aggiunge anche un set di direttive impliciteglobal using per i progetti che usano gli SDK seguenti:

Microsoft.NET.Sdk
Microsoft.NET.Sdk.Web
Microsoft.NET.Sdk.Worker

Queste direttive implicite global using includono gli spazi dei nomi più comuni per il tipo di progetto.

Per altre informazioni, vedere l'articolo sull'uso implicito delle direttive

Aprire Program.cs nell'editor preferito e sostituire il codice esistente con il seguente:

List<string> names = ["<name>", "Ana", "Felipe"];
foreach (var name in names)
{
    Console.WriteLine($"Hello {name.ToUpper()}!");
}

Sostituire <name> con il proprio nome. Salvare Program.cs. Digitare dotnet run nella finestra della console per provare il codice.

È stato creato un elenco di stringhe, sono stati aggiunti tre nomi all'elenco e sono stati stampati i nomi in tutti i CAPS. Vengono usati i concetti appresi nelle esercitazioni precedenti per eseguire il ciclo dell'elenco.

Il codice per visualizzare i nomi usa la funzionalità di interpolazione di stringhe. Anteponendo il carattere $ a string, è possibile incorporare il codice C# nella dichiarazione della stringa. La stringa effettiva sostituisce il codice C# con il valore generato. In questo esempio, {name.ToUpper()} viene sostituito con ogni nome, convertito in lettere maiuscole, perché è stato chiamato il metodo ToUpper.

L'esplorazione continua nelle prossime lezioni.

Modificare il contenuto dell'elenco

La raccolta creata usa il tipo List<T>. Questo tipo archivia sequenze di elementi. Il tipo degli elementi viene specificato tra parentesi uncinate.

Un aspetto importante di questo tipo di List<T> è che supporta estensioni o riduzioni, consentendo l'aggiunta o la rimozione di elementi. Aggiungere questo codice alla fine del programma:

Console.WriteLine();
names.Add("Maria");
names.Add("Bill");
names.Remove("Ana");
foreach (var name in names)
{
    Console.WriteLine($"Hello {name.ToUpper()}!");
}

Sono stati aggiunti altri due nomi alla fine dell'elenco e ne è stato anche rimosso uno. Salvare il file e digitare dotnet run per provare il codice.

List<T> consente di fare riferimento a singoli elementi anche in base all'indice. Inserire l'indice tra i token [ e ] dopo il nome dell'elenco. C# usa il valore 0 per il primo indice. Aggiungere questo codice direttamente sotto il codice appena aggiunto e provarlo:

Console.WriteLine($"My name is {names[0]}");
Console.WriteLine($"I've added {names[2]} and {names[3]} to the list");

Non è possibile accedere a un indice oltre la fine dell'elenco. Tenere presente che gli indici iniziano da 0, pertanto l'indice massimo valido è minore di un'unità rispetto al numero di elementi nell'elenco. È possibile controllare la lunghezza dell'elenco tramite la proprietà Count. Aggiungere il codice seguente alla fine del programma:

Console.WriteLine($"The list has {names.Count} people in it");

Salvare il file e digitare di nuovo dotnet run per visualizzare i risultati.

Eseguire ricerche negli elenchi e ordinarli

In questi esempi vengono usati elenchi relativamente piccoli, ma le applicazioni reali creano spesso elenchi con molti più elementi, a volte anche migliaia. Per trovare elementi in raccolte di tali dimensioni, è necessario avere la possibilità di eseguire ricerche nell'elenco. Il metodo IndexOf cerca un elemento e ne restituisce l'indice. Se l'elemento non è nell'elenco, IndexOf restituisce -1. Aggiungere questo codice alla fine del programma:

var index = names.IndexOf("Felipe");
if (index == -1)
{
    Console.WriteLine($"When an item is not found, IndexOf returns {index}");
}
else
{
    Console.WriteLine($"The name {names[index]} is at index {index}");
}

index = names.IndexOf("Not Found");
if (index == -1)
{
    Console.WriteLine($"When an item is not found, IndexOf returns {index}");
}
else
{
    Console.WriteLine($"The name {names[index]} is at index {index}");

}

Gli elementi in un elenco possono anche essere ordinati. Il Sort metodo ordina tutti gli elementi dell'elenco nell'ordine normale (alfabeticamente per le stringhe). Aggiungere questo codice alla fine del programma:

names.Sort();
foreach (var name in names)
{
    Console.WriteLine($"Hello {name.ToUpper()}!");
}

Salvare il file e digitare dotnet run per provare quest'ultima versione.

Prima di iniziare la sezione successiva, è necessario spostare il codice corrente in un metodo separato. In questo modo sarà più semplice iniziare a lavorare con un nuovo esempio. Inserire tutto il codice scritto in un nuovo metodo denominato WorkWithStrings(). Chiamare il metodo nella parte superiore del programma. Al termine, il codice dovrebbe essere simile al seguente:

WorkWithStrings();

void WorkWithStrings()
{
    List<string> names = ["<name>", "Ana", "Felipe"];
    foreach (var name in names)
    {
        Console.WriteLine($"Hello {name.ToUpper()}!");
    }

    Console.WriteLine();
    names.Add("Maria");
    names.Add("Bill");
    names.Remove("Ana");
    foreach (var name in names)
    {
        Console.WriteLine($"Hello {name.ToUpper()}!");
    }

    Console.WriteLine($"My name is {names[0]}");
    Console.WriteLine($"I've added {names[2]} and {names[3]} to the list");

    Console.WriteLine($"The list has {names.Count} people in it");

    var index = names.IndexOf("Felipe");
    if (index == -1)
    {
        Console.WriteLine($"When an item is not found, IndexOf returns {index}");
    }
    else
    {
        Console.WriteLine($"The name {names[index]} is at index {index}");
    }

    index = names.IndexOf("Not Found");
    if (index == -1)
    {
        Console.WriteLine($"When an item is not found, IndexOf returns {index}");
    }
    else
    {
        Console.WriteLine($"The name {names[index]} is at index {index}");

    }

    names.Sort();
    foreach (var name in names)
    {
        Console.WriteLine($"Hello {name.ToUpper()}!");
    }
}

Elenchi di altri tipi

Finora è stato usato il tipo string negli elenchi. Di seguito verrà creato un List<T> con un tipo diverso. Per iniziare, creare un set di numeri.

Aggiungere quanto segue al programma dopo aver chiamato WorkWithStrings():

List<int> fibonacciNumbers = [1, 1];

Questo codice crea un elenco di interi e imposta i primi due interi sul valore 1. Questi sono i primi due valori di una successione di Fibonacci, ovvero una sequenza di numeri. Ogni numero della successione di Fibonacci viene ottenuto dalla somma dei due numeri precedenti. Aggiungere questo codice:

var previous = fibonacciNumbers[fibonacciNumbers.Count - 1];
var previous2 = fibonacciNumbers[fibonacciNumbers.Count - 2];

fibonacciNumbers.Add(previous + previous2);

foreach (var item in fibonacciNumbers)
{
    Console.WriteLine(item);
}

Salvare il file e digitare dotnet run per visualizzare i risultati.

Suggerimento

Per concentrarsi solo su questa sezione, è possibile impostare come commento il codice che chiama WorkWithStrings();. Basta inserire due / caratteri davanti alla chiamata come questo: // WorkWithStrings();.

Sfida

È il momento di scoprire se è possibile mettere in pratica alcuni dei concetti appresi in questa lezione e in quelle precedenti. Applicare i concetti appresi finora in relazione ai numeri di Fibonacci. Provare a scrivere il codice per generare i primi 20 numeri nella successione. Tenere presente che il 20° numero di Fibonacci è 6765.

Completare l'esercizio

È possibile visualizzare una soluzione di esempio esaminando il codice di esempio completato su GitHub.

A ogni iterazione del ciclo, gli ultimi due interi nell'elenco vengono sommati e il valore risultante viene aggiunto all'elenco. Il ciclo viene ripetuto fino ad aggiungere 20 elementi all'elenco.

Complimenti, è stata completata questa esercitazione dedicata agli elenchi. È possibile continuare con altre esercitazioni nell'ambiente di sviluppo.

Per altre informazioni sull'uso del tipo, vedere l'articolo List Concetti fondamentali di .NET sulle raccolte. Questo argomento include anche informazioni su molti altri tipi di raccolta.