Lär dig att hantera datasamlingar med list<T> i C#

Artikel
07/12/2023

Den här introduktionskursen ger en introduktion till C#-språket och grunderna i List<T> klassen.

Förutsättningar

Självstudien förväntar sig att du har en dator konfigurerad för lokal utveckling. Se Konfigurera din lokala miljö för installationsinstruktioner och en översikt över programutveckling i .NET.

Om du föredrar att köra koden utan att behöva konfigurera en lokal miljö kan du läsa den interaktiva webbläsarversionen av den här självstudien.

Ett exempel på en grundläggande lista

Skapa en katalog med namnet list-tutorial. Gör det till den aktuella katalogen och kör dotnet new console.

Viktigt

C#-mallarna för .NET 6 använder toppnivåinstruktioner. Ditt program kanske inte matchar koden i den här artikeln om du redan har uppgraderat till .NET 6. Mer information finns i artikeln om nya C#-mallar som genererar instruktioner på toppnivå

.NET 6 SDK lägger också till en uppsättning implicitaglobal using direktiv för projekt som använder följande SDK:er:

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

Dessa implicita global using direktiv innehåller de vanligaste namnrymderna för projekttypen.

Mer information finns i artikeln om implicit användning av direktiv

Öppna Program.cs i din favoritredigerare och ersätt den befintliga koden med följande:

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

Ersätt <name> med ditt namn. Spara Program.cs. Skriv dotnet run in konsolfönstret för att prova det.

Du har skapat en lista med strängar, lagt till tre namn i listan och skrivit ut namnen i alla CAPS. Du använder begrepp som du har lärt dig i tidigare självstudier för att gå igenom listan.

Koden för att visa namn använder funktionen för stränginterpolation . När du föregår ett string med $ tecknet kan du bädda in C#-kod i strängdeklarationen. Den faktiska strängen ersätter C#-koden med det värde som genereras. I det här exemplet ersätts {name.ToUpper()} med varje namn, konverterat till versaler, eftersom du anropade ToUpper metoden.

Låt oss fortsätta utforska.

Ändra listinnehåll

Samlingen som du skapade använder typen List<T> . Den här typen lagrar sekvenser av element. Du anger typen av element mellan vinkelparenteserna.

En viktig aspekt av den här List<T> typen är att den kan växa eller krympa, så att du kan lägga till eller ta bort element. Lägg till den här koden i slutet av programmet:

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

Du har lagt till ytterligare två namn i slutet av listan. Du har också tagit bort en. Spara filen och skriv dotnet run för att prova den.

Gör List<T> att du även kan referera till enskilda objekt efter index . Du placerar indexet mellan [ och ] token efter listnamnet. C# använder 0 för det första indexet. Lägg till den här koden direkt under koden som du nyss lade till och prova den:

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

Du kan inte komma åt ett index längre än till slutet av listan. Kom ihåg att index börjar vid 0, så det största giltiga indexet är ett mindre än antalet objekt i listan. Du kan kontrollera hur länge listan använder Count egenskapen . Lägg till följande kod i slutet av programmet:

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

Spara filen och skriv dotnet run igen för att se resultatet.

Sök- och sorteringslistor

Våra exempel använder relativt små listor, men dina program kan ofta skapa listor med många fler element, ibland numrerade i tusental. Om du vill hitta element i dessa större samlingar måste du söka i listan efter olika objekt. Metoden IndexOf söker efter ett objekt och returnerar objektets index. Om objektet inte finns i listan IndexOf returnerar -1. Lägg till den här koden längst ned i programmet:

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}");

}

Objekten i listan kan också sorteras. Metoden Sort sorterar alla objekt i listan i normal ordning (alfabetiskt för strängar). Lägg till den här koden längst ned i programmet:

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

Spara filen och skriv dotnet run för att prova den senaste versionen.

Innan du börjar nästa avsnitt ska vi flytta den aktuella koden till en separat metod. Det gör det enklare att börja arbeta med ett nytt exempel. Placera all kod som du har skrivit i en ny metod med namnet WorkWithStrings(). Anropa den metoden överst i programmet. När du är klar bör koden se ut så här:

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()}!");
    }
}

Listor över andra typer

Du har använt string typen i listor hittills. Nu ska vi göra en List<T> med en annan typ. Nu ska vi skapa en uppsättning tal.

Lägg till följande i programmet när du har anropat WorkWithStrings():

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

Då skapas en lista med heltal och de två första heltalen anges till värdet 1. Det här är de två första värdena i en Fibonacci-sekvens, en sekvens med tal. Varje nästa Fibonacci-nummer hittas genom att ta summan av de föregående två talen. Lägg till den här koden:

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

fibonacciNumbers.Add(previous + previous2);

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

Spara filen och skriv dotnet run för att se resultatet.

Tips

Om du vill koncentrera dig på just det här avsnittet kan du kommentera ut koden som anropar WorkWithStrings();. Placera bara två / tecken framför anropet så här: // WorkWithStrings();.

Uppgift

Se om du kan sätta ihop några av begreppen från den här och tidigare lektioner. Utöka det du har skapat hittills med Fibonacci-nummer. Försök att skriva koden för att generera de första 20 talen i sekvensen. (Som ett tips är det 20:e Fibonacci-numret 6765.)

Utmaningen

Du kan se en exempellösning genom att titta på den färdiga exempelkoden på GitHub.

Med varje iteration av loopen tar du de två sista heltalen i listan, summerar dem och lägger till det värdet i listan. Loopen upprepas tills du har lagt till 20 objekt i listan.

Grattis, du har slutfört listguiden. Du kan fortsätta med ytterligare självstudier i din egen utvecklingsmiljö.

Du kan lära dig mer om att arbeta med List typen i .NET Fundamentals-artikeln om samlingar. Du får också lära dig om många andra samlingstyper.