C# tillhandahåller en rik uppsättning samlingstyper i System.Collections.Generic för att lagra datagrupper. De vanligaste är List<T> (dynamisk array), Dictionary<K,V> (nyckel-värde-map) och HashSet<T> (unik uppsättning). Att välja rätt typ är viktigt för tydlighet och prestanda.
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> är standardsamlingen för generell användning — en ordnad, storleksändringsbar, indexerad lista. <T> är en generisk typparameter (List<string>, List<User>), vilket ger typkontroll vid kompileringsstid.
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> mappar nycklar till värden med snabba O(1)-sökningar — för cacheminnen, index och all nyckelbaserad åtkomst. TryGetValue är det säkra sättet att söka upp värden (undviker undantag när nyckeln saknas).
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[])
Samlingar är fundamentala för nästan alla program — lagring och bearbetning av datagrupper är konstant — så förståelse för C#:s vanliga samlingstyper och ett bra val är essentiell kunskap i det dagliga arbetet.
Att känna till huvudtyperna och deras användningsfall — List<T> för ordnad, indexerad, storleksändringsbar data (arbetshästen för generell användning), Dictionary<K,V> för snabb nyckelbaserad sökning (cacheminnen, index), HashSet<T> för unikhet och snabba medlemskapstest, och Queue/Stack för FIFO/LIFO-bearbetning — är nödvändigt för att skriva effektiv, tydlig kod.
Valet påverkar direkt prestanda (t.ex. en Dictionarys O(1)-sökning jämfört med att genomsöka en Lists O(n), eller HashSets O(1)-medlemskap jämfört med Lists O(n)) och intention, så att välja lämplig samling istället för att som standard använda List<T> för allt är en viktig färdighet.
Dessa samlingar är också generiska (<T>), vilket ger typkontroll vid kompileringsstid.
Att känna till praktiska detaljer som TryGetValue för säkra ordbok-sökningar (undvika undantag vid saknade nycklar) och prestanda-karakteristiken för varje typ täcker de dagliga behoven när man arbetar med data i C#.
Då samlingar förekommer i praktiskt taget alla program och rätt val på ett meningsfullt sätt påverkar prestanda och läsbarhet, är det att behärska de vanliga samlingstyperna och deras lämpliga användning grundläggande, måste-känna kunskap för effektiv C#-utveckling.