C# tilbyr et rikt sett av kolleksjonstyper i System.Collections.Generic for lagring av datagrupper. De mest vanlige er List<T> (dynamisk matrise), Dictionary<K,V> (nøkkel-verdi-kart), og HashSet<T> (unikt sett). Å velge riktig type er viktig for klarhet og ytelse.
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 foretrukne generelle kolleksjonsalternativet — en ordnet, dynamisk, indeksert liste. <T> er en generisk typeparameter (List<string>, List<User>), som gir typesikkerhet ved kompilering.
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> kartlegger nøkler til verdier med raske O(1)-oppslag — for mellomlagring, indekser og enhver nøkkelbasert tilgang. TryGetValue er den sikre måten å slå opp på (unngår unntak når nøkkelen 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[])
Kolleksjoner er fundamentale for nesten alle programmer — lagring og behandling av datagrupper er konstant — så forståelse av C#'s vanlige kolleksjonstyper og riktig valg er essensiell, daglig kunnskap.
Kjennskap til hoveddypene og deres brukstilfeller — List<T> for ordnet, indeksert, dynamisk data (generell arbeidssamling), Dictionary<K,V> for raskt nøkkelbasert oppslag (mellomlagring, indekser), HashSet<T> for unikhet og raske medlemskapstester, og Queue/Stack for FIFO/LIFO-behandling — er nødvendig for å skrive effektiv, klar kode.
Valgene påvirker direkte ytelse (f.eks. Dictionarys O(1)-oppslag kontra skanningav Lists O(n), eller HashSets O(1)-medlemskap kontra Lists O(n)) og intensjon, så å velge passende kolleksjon i stedet for å alltid bruke List<T> er en viktig ferdighet.
Disse kolleksjonene er også generiske (<T>), og gir typesikkerhet ved kompilering.
Kjennskap til praktiske detaljer som TryGetValue for sikre Dictionary-oppslag (unngår unntak ved manglende nøkler) og ytelsesegenskapene for hver type dekker det daglige behovet for å arbeide med data i C#.
Siden kolleksjoner finnes i praktisk talt alle programmer og riktig valg påvirker ytelse og lesbarhet på en meningsfull måte, er det grunnleggende og viktig kunnskap for effektiv C#-utvikling å mestre de vanlige kolleksjonsdypene og deres passende bruk.
Et bibliotek av IT-intervjuspørsmål med detaljerte svar — fra Junior til Senior.
Doner