C# oferă o mulțime bogată de tipuri de colecții în System.Collections.Generic pentru stocarea grupurilor de date. Cele mai comune sunt List<T> (matrice dinamică), Dictionary<K,V> (hartă cheie-valoare) și HashSet<T> (set unic). Alegerea celui potrivit contează pentru claritate și performanță.
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> este colecția general-purpose de referință — o listă ordonată, redimensionabilă, indexată. <T> este un parametru de tip generic (List<string>, List<User>), oferind siguranță de tip la compile-time.
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> mapează chei la valori cu căutări rapide O(1) — pentru cache-uri, indecși și orice acces bazat pe chei. TryGetValue este modul sigur de căutare (evitând o excepție când cheia lipsește).
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[])
Colecțiile sunt fundamentale pentru aproape fiecare program — stocarea și procesarea grupurilor de date este constantă — deci înțelegerea tipurilor comune de colecții din C# și alegerea judicioasă sunt cunoștințe esențiale zilnice.
Cunoașterea tipurilor principale și a cazurilor de utilizare — List<T> pentru date ordonate, indexate, redimensionabile (muncitorul general-purpose), Dictionary<K,V> pentru căutare rapidă bazată pe chei (cache-uri, indecși), HashSet<T> pentru unicitate și teste rapide de appartență, și Queue/Stack pentru procesare FIFO/LIFO — este necesară pentru scrierea de cod eficient și clar.
Alegerea afectează direct performanța (de ex. căutare O(1) a Dictionary versus scanarea O(n) a List, sau appartența O(1) a HashSet versus O(n) a List) și intenția, deci alegerea colecției potrivite în loc să se recurgă implicit la List<T> pentru totul este o abilitate importantă.
Aceste colecții sunt, de asemenea, generice (<T>), oferind siguranță de tip la compile-time.
Cunoașterea detaliilor practice cum ar fi TryGetValue pentru căutări sigure în dicționar (evitând excepții pentru chei lipsă) și caracteristicile de performanță ale fiecărui tip acoperă nevoile zilnice de lucru cu date în C#.
Deoarece colecțiile apar în aproape fiecare program și alegerea corectă afectează în mod semnificativ performanța și lizibilitatea, stăpânirea tipurilor comune de colecții și utilizarea lor corespunzătoare este cunoștință fundamentală, pe care trebuie să o cunoști, pentru dezvoltarea eficace în C#.
O bibliotecă de întrebări de interviu IT cu răspunsuri detaliate — de la Junior la Senior.
Donează