A C# gazdag gyűjteménytípus-készletet biztosít a System.Collections.Generic névterben adatcsoportok tárolásához. A leggyakoribbak a List<T> (dinamikus tömb), a Dictionary<K,V> (kulcs-érték térkép) és a HashSet<T> (egyedi készlet). A megfelelő választás fontos az átláthatóság és a teljesítmény szempontjából.
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
A List<T> az alapértelmezett általános célú gyűjtemény — egy rendezett, átméretezhető, indexelt lista. A <T> egy generikus típusparaméter (List<string>, List<User>), amely fordítási idejű típusbiztonságot nyújt.
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
A Dictionary<K,V> kulcsokat leképez értékekre gyors O(1) keresésekkel — gyorsítótárakhoz, indexekhez és bármilyen kulcsalapú hozzáféréshez. A TryGetValue a biztonságos keresési mód (elkerülve a kivételt, ha a kulcs hiányzik).
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[])
A gyűjtemények szinte minden program alapjai — az adatcsoportok tárolása és feldolgozása állandó — ezért a C# gyakori gyűjteménytípusainak ismerete és a jó választás napi szinten fontos tudás.
A fő típusok és felhasználási eseteik ismerete — a List<T> rendezett, indexelt, átméretezhető adatokhoz (az általános célú munkaló), a Dictionary<K,V> gyors kulcsalapú kereséshez (gyorsítótárak, indexek), a HashSet<T> egyediséghez és gyors tagságvizsgálathoz, valamint a Queue/Stack FIFO/LIFO feldolgozáshoz — szükséges a hatékony, tiszta kód írásához.
A választás közvetlenül befolyásolja a teljesítményt (például a Dictionary O(1) keresése a List O(n) vizsgálatához képest, vagy a HashSet O(1) tagsága a List O(n) tagsága helyett) és a szándékot, ezért az alapértelmezett List<T> helyett a megfelelő gyűjtemény kiválasztása fontos készség.
Ezek a gyűjtemények szintén generikusak (<T>), fordítási idejű típusbiztonságot biztosítva.
A praktikus részletek ismerete, mint például a TryGetValue biztonságos szótári keresésekhez (hiányzó kulcsok miatti kivételek elkerülése) és az egyes típusok teljesítményjellemzői, a C#-ban az adatokkal való munka mindennapi igényeit fedezi.
Mivel a gyűjtemények szinte minden programban megjelennek, és a helyes választás értelmes módon befolyásolja a teljesítményt és az olvashatóságot, a gyakori gyűjteménytípusok és azok megfelelő felhasználása elsajátítása alapvető, nélkülözhetetlen tudás az effektív C# fejlesztéshez.