C# biedt een rijke reeks verzamelingstypen in System.Collections.Generic voor het opslaan van groepen gegevens. De meest gebruikte zijn List<T> (dynamische array), Dictionary<K,V> (sleutel-waardekaart), en HashSet<T> (unieke verzameling). Het kiezen van het juiste type is belangrijk voor helderheid en prestaties.
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> is de standaardkeuze voor een algemeen doel verzameling — een geordende, herschaalbare, geïndexeerde lijst. De <T> is een generieke typeparameter (List<string>, List<User>), die compile-time typeveiligheid biedt.
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> kaart sleutels op waarden met snelle O(1) lookups — voor caches, indexen, en elke op sleutel gebaseerde toegang. TryGetValue is de veilige manier om op te zoeken (voorkoming van een uitzondering wanneer de sleutel ontbreekt).
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[])
Verzamelingen zijn fundamenteel voor bijna elk programma — het opslaan en verwerken van groepen gegevens is constant — dus het begrijpen van C#'s veelgebruikte verzamelingstypen en het goed kiezen is essentiële dagelijkse kennis.
Het kennen van de belangrijkste typen en hun gebruiksscenario's — List<T> voor geordende, geïndexeerde, herschaalbare gegevens (het algemene doel werkpaard), Dictionary<K,V> voor snelle op sleutel gebaseerde lookup (caches, indexen), HashSet<T> voor uniciteit en snelle lidmaatschapstests, en Queue/Stack voor FIFO/LIFO verwerking — is noodzakelijk voor het schrijven van efficiënte, heldere code.
De keuze beïnvloedt rechtstreeks prestaties (bijv. een Dictionary's O(1) lookup versus het scannen van een List's O(n), of HashSet's O(1) lidmaatschap versus List's O(n)) en intentie, dus het kiezen van de passende verzameling in plaats van standaard List<T> voor alles gebruiken is een belangrijk vaardigheden.
Deze verzamelingen zijn ook generiek (<T>), wat compile-time typeveiligheid biedt.
Het kennen van praktische details zoals TryGetValue voor veilige dictionary lookups (voorkoming van uitzonderingen op ontbrekende sleutels) en de prestatie karakteristieken van elk type bestrijkt de dagelijkse behoeften van het werken met gegevens in C#.
Aangezien verzamelingen vrijwel in elk programma voorkomen en de juiste keuze betekenisvol de prestaties en leesbaarheid beïnvloedt, is het beheersen van de veelgebruikte verzamelingstypen en hun passende gebruik fundamentele, onontbeerlijke kennis voor effectieve C# ontwikkeling.