C# tilbyder et omfattende sæt af collection-typer i System.Collections.Generic til opbevaring af datagrupper. De mest almindelige er List<T> (dynamisk array), Dictionary<K,V> (nøgle-værdi-kort) og HashSet<T> (unikt sæt). At vælge den rigtige type betyder noget for klarhed og performance.
var numbers = new List<int> { 1, 2, 3 };
numbers.Add(4); // grows dynamically
numbers[0]; // index access — O(1)
numbers.Contains(3); // O(n) search
numbers.Remove(2);
numbers.Count; // size
foreach (var n in numbers) { } // iterate
List<T> er det generelle formål-collection — en ordnet, resizable, indekseret liste. <T> er en generisk type-parameter (List<string>, List<User>), hvilket giver compile-time type-sikkerhed.
var ages = new Dictionary<string, int> { ["Ann"] = 30, ["Bob"] = 25 };
ages["Carol"] = 28; // add/set
ages["Ann"]; // get by key — O(1)
ages.ContainsKey("Ann");
ages.TryGetValue("Ann", out var age); // safe lookup (no exception if missing)
foreach (var (name, a) in ages) { } // iterate key-value pairs
Dictionary<K,V> kortlægger nøgler til værdier med hurtige O(1) opslag — til caches, indekser og ethvert nøgle-baseret adgang. TryGetValue er den sikre måde at slå op på (undgå en exception når nøglen mangler).
var set = new HashSet<int> { 1, 2, 3 }; // unique elements, O(1) Contains
set.Add(2); // ignored (duplicate)
var queue = new Queue<int>(); // FIFO
var stack = new Stack<int>(); // LIFO
int[] arr = { 1, 2, 3 }; // fixed-size array
var ro = numbers.AsReadOnly(); // read-only wrapper
Ordered, indexed, resizable → List<T>
Key-value lookup (fast) → Dictionary<K,V>
Uniqueness / fast membership → HashSet<T>
FIFO / LIFO processing → Queue<T> / Stack<T>
Fixed size / performance-critical → array (T[])
Collections er grundlæggende for næsten ethvert program — opbevaring og behandling af datagrupper er konstant — så forståelse af C#'s almindelige collection-typer og valg af de rigtige er væsentlig daglig viden.
At kende hovednyperne og deres use cases — List<T> til ordnet, indekseret, resizable data (den generelle-formål arbejdshest), Dictionary<K,V> til hurtigt nøgle-baseret opslag (caches, indekser), HashSet<T> til enestadighed og hurtige medlemskabstests, og Queue/Stack til FIFO/LIFO-behandling — er nødvendigt for at skrive effektiv, klar kode.
Valget påvirker direkte performance (f.eks. en Dictionarys O(1) opslag vs scanning af en Lists O(n), eller HashSets O(1) medlemskab vs Lists O(n)) og hensigt, så at vælge det passende collection i stedet for at defaulte til List<T> til alt er en vigtig færdighed.
Disse collections er også generiske (<T>), hvilket giver compile-time type-sikkerhed.
At kende praktiske detaljer som TryGetValue til sikre dictionary-opslag (undgå exceptions ved manglende nøgler) og performance-karakteristikaerne for hver type dækker de daglige behov for at arbejde med data i C#.
Da collections optræder i praktisk talt hvert program, og det rigtige valg meningsfuldt påvirker performance og læsbarhed, er det at mestre de almindelige collection-typer og deres passende brug grundlæggende, vigtig viden for effektiv C#-udvikling.