C# inatoa seti tajiri ya aina za collection katika System.Collections.Generic kwa kuhifadhi makundi ya data. Za kawaida zaidi ni List<T> (dynamic array), Dictionary<K,V> (key-value map), na HashSet<T> (unique set). Kuchagua iliyo sahihi ni muhimu kwa uwazi na performance.
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> ndio collection ya kawaida ya matumizi-jumla — orodha iliyopangwa, inayoweza kubadilishwa ukubwa, na indexed. <T> ni generic type parameter (List<string>, List<User>), ikitoa compile-time type safety.
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> huramani keys na values kwa lookups za haraka za O(1) — kwa caches, indexes, na ufikiaji wowote unaotegemea key. TryGetValue ni njia salama ya kufanya lookup (kuepuka exception wakati key haipo).
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[])
Collections ni za msingi kwa karibu kila programu — kuhifadhi na kuchakata makundi ya data ni jambo la mara kwa mara — hivyo kuelewa aina za kawaida za collection za C# na kuchagua vizuri ni maarifa ya lazima ya kila siku.
Kujua aina kuu na matumizi yake — List<T> kwa data iliyopangwa, indexed, inayoweza kubadilishwa ukubwa (kifaa cha matumizi-jumla), Dictionary<K,V> kwa lookup ya haraka inayotegemea key (caches, indexes), HashSet<T> kwa uniqueness na vipimo vya haraka vya membership, na Queue/Stack kwa uchakataji wa FIFO/LIFO — ni lazima kwa kuandika msimbo wenye ufanisi na wazi.
Uchaguzi unaathiri moja kwa moja performance (mfano lookup ya O(1) ya Dictionary dhidi ya kuchanganua O(n) ya List, au membership ya O(1) ya HashSet dhidi ya O(n) ya List) na nia, hivyo kuchagua collection inayofaa badala ya kurudi kwa List<T> kwa kila kitu ni ujuzi muhimu.
Collections hizi pia ni generic (<T>), zikitoa compile-time type safety.
Kujua maelezo ya vitendo kama TryGetValue kwa lookups salama za dictionary (kuepuka exceptions kwa keys zisizopo) na sifa za performance za kila aina kunashughulikia mahitaji ya kila siku ya kufanya kazi na data katika C#.
Kwa kuwa collections zinaonekana katika karibu kila programu na uchaguzi sahihi unaathiri performance na usomekaji kwa kiasi kikubwa, kumiliki aina za kawaida za collection na matumizi yake yanayofaa ni maarifa ya msingi, ya lazima kwa maendeleo bora ya C#.