Arrays, lister og dictionaries

Rækketyper som arrays, lister og dictionaries samler flere værdier under ét navn — så du kan pege på en hel samling med én variabel i stedet for ti enkeltvariabler.

Fra simple typer til samlinger

En int er 32 bit (4 bytes) og gemmer én værdi. double, float og decimal fylder mere grundet deres præcision. char er 16 bit i C# (Unicode), selvom mange tegn kun bruger 8 bit.

Disse kaldes simple datatyper eller primitive typer — de kan vises som enkelt værdier:

int age = 17;       // én værdi
char letter = 'A';  // ét tegn

Hvad gør vi, når vi vil gemme mange værdier — fx en række tal eller tegn? Her kommer arrays og lister ind. I har faktisk allerede brugt dem: en string er en sekvens af tegn — i C# et objekt, men idéen er den samme som en række char-værdier bundet sammen.

Arrays

Et array gemmer en samling af elementer af samme type med fast størrelse.

Arrays er indekserede — hvert element har en plads (indeks), og du tilgår dem med [indeks]:

int[] numbers = { 1, 2, 3, 4, 5 }

  [0]    [1]    [2]    [3]    [4]
   1  →   2  →   3  →   4  →   5

Opret et array med fast størrelse:

int[] numbers = new int[10];   // 10 heltal, initialiseret til 0

Initialiser med værdier:

int[] numbers = { 10, 20, 30 };

Tilgå og ændre elementer — indeks starter altid ved 0:

Arrays er effektive når størrelsen er kendt og uforanderlig — fx ugedage (7), oktetter i en IP (4), eller en fast liste scores.

Lister

En List<T> kan vokse og krympe dynamisk — den mest brugte samling i daglig C#.

using System.Collections.Generic;

List<int> numbers = new List<int>();

Tilføj elementer:

numbers.Add(10);
numbers.Add(20);
numbers.Add(30);

Tilgå og ændre via indeks — samme syntaks som arrays:

Flere metoder:

var names = new List<string> { "Ada", "Alan" };

names.Add("Grace");          // tilføj til slutningen
names.Insert(0, "Grace H."); // indsæt på indeks
names.Remove("Alan");        // fjern efter værdi
names.Clear();               // fjern alle

Lister er reference-typer — variablen peger på listen i hukommelsen, ikke en kopi. Vær opmærksom, når du deler lister mellem metoder.

Arrays vs. lister — hvornår bruger man hvad?

Emne	Array	List<T>
Hukommelse	Mindre — ingen ekstra metoder	Lidt mere — baggrund og metoder
Størrelse	Fast ved oprettelse	Dynamisk — Add/Remove
Adgang	Hurtig, kontinuerlig blok	Fleksibel tilføjelse/fjernelse
Tilføj element	❌ fast størrelse	✅ .Add()
Fjern element	❌	✅ .Remove()
Tilgå element	numbers[0]	names[0]
Antal elementer	.Length	.Count
Loop	for / foreach	for / foreach

Generelt: Kender du størrelsen på forhånd og skal den ikke ændres → array. Skal samlingen vokse eller krympe → liste.

I praksis vælger mange udviklere liste som standard — den er mere fleksibel.

Videoer

Se det i praksis

List&lt;T&gt; and Collections of Data [Pt 12] | C# for Beginners

Arrays, Lists, Indexing, and Foreach [Pt 13] | C# for Beginners

Sorting and Searching Lists [Pt 14] | C# for Beginners

Dictionary — nøgle og værdi

En Dictionary<TKey, TValue> gemmer nøgle/værdi-par. Den er bygget som et hash map, så opslag på nøgle er meget effektivt — typisk O(1) (konstant tid).

Dictionary (Microsoft Docs)

Dictionary<string, int> ageMap = new Dictionary<string, int>();

ageMap.Add("Anders", 25);
ageMap.Add("Line", 30);

int lineAge = ageMap["Line"];   // 30 — opslag via nøgle

Tilføj eller opdater med indexer-syntaks:

ageMap["Grace"] = 22;   // tilføj ny
ageMap["Anders"] = 26;  // opdater eksisterende

Sikkert opslag med TryGetValue — undgår fejl hvis nøglen ikke findes:

Hash-funktionen fordeler nøgler i buckets — derfor er opslag hurtigt uden at gennemsøge hele listen.

Sammenligning — array, liste og dictionary

Metode	Array	List<T>	Dictionary<K,V>
Tilføj element	❌ fast størrelse	✅ .Add()	✅ .Add(key, val)
Fjern element	❌	✅ .Remove()	✅ .Remove(key)
Tilgå element	numbers[0]	names[0]	map["Anders"]
Loop	for / foreach	for / foreach	foreach KeyValuePair
Antal	.Length	.Count	.Count

Vælg datastruktur:

1. Skal du gemme flere værdier af samme type?
2. Kender du størrelsen? → Ja → array. Nej → videre.
3. Har du brug for nøgler? → Nej → liste. Ja → dictionary.

Iteration over samlinger

Alle tre kan gennemløbes med loops — se også kapitlet Loops:

Praktisk eksempel — elever og karakterer

Mønsteret liste over nøgler + dictionary med data genbruges i mange GF2-opgaver og projekter.

Opsummering

• Arrays — fast størrelse, effektiv indeksering, god til kendte mængder
• Lister — dynamisk størrelse, Add/Remove, standardvalg i moderne C#
• Dictionaries — nøgle/værdi-opslag, hurtig hash-baseret adgang
• Vælg struktur efter problem: fast størrelse, dynamisk samling eller opslag på navn

Test din viden

Spørgsmål 1

Hvad er hovedforskellen på et array og en List<T>?

• Arrays kan kun indeholde strings

• Et array har fast størrelse; en liste kan vokse og krympe dynamisk

• Lister er primitiv type; arrays er reference-type

Spørgsmål 2

Hvilket indeks har første element i et array?

• 1

• 0

• -1

Spørgsmål 3

Hvornår er en Dictionary det rigtige valg?

• Når du skal gemme mange tal i rækkefølge uden navne

• Når du skal slå data op via en nøgle (fx navn → alder)

• Når størrelsen er kendt og aldrig ændres

Spørgsmål 4

Hvad returnerer ageMap.TryGetValue("Ada", out int age) hvis nøglen ikke findes?

• Den kaster en exception

• false — og age får standardværdien 0

• true med age sat til -1

Spørgsmål 5

Hvad er gyldige indeks for et array med Length = 10?

• 0 til 10 (inklusiv)

• 0 til 9

• 1 til 10

Spørgsmål 6

Hvilken property bruger du til antal elementer i en List<string>?

• .Length

• .Count

• .Size

Spørgsmål 7

Ifølge huskereglen i kapitlet — hvornår vælger du et array?

• Når du ikke ved, hvor mange elementer der kommer

• Når du kender størrelsen på forhånd og den ikke skal ændres — fx 7 ugedage

• Når du skal slå op på navn