C# data के समूहों को store करने के लिए System.Collections.Generic में collection types का एक समृद्ध सेट प्रदान करता है। सबसे सामान्य हैं List<T> (dynamic array), Dictionary<K,V> (key-value map), और HashSet<T> (unique set)। सही वाला चुनना स्पष्टता और 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> go-to general-purpose collection है — एक ordered, resizable, indexed list। <T> एक generic type parameter है (List<string>, List<User>), जो 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> keys को values से तेज़ O(1) lookups के साथ map करता है — caches, indexes, और किसी भी key-based access के लिए। TryGetValue lookup करने का safe तरीका है (key के गायब होने पर exception से बचते हुए)।
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 लगभग हर program के लिए मूलभूत हैं — data के समूहों को store और process करना निरंतर होता है — इसलिए C# के सामान्य collection types को समझना और अच्छी तरह चुनना आवश्यक रोजमर्रा का ज्ञान है।
मुख्य types और उनके use cases को जानना — ordered, indexed, resizable data के लिए List<T> (general-purpose workhorse), तेज़ key-based lookup के लिए Dictionary<K,V> (caches, indexes), uniqueness व तेज़ membership tests के लिए HashSet<T>, और FIFO/LIFO processing के लिए Queue/Stack — efficient, स्पष्ट code लिखने के लिए आवश्यक है।
यह choice सीधे performance (जैसे एक Dictionary का O(1) lookup बनाम एक List को O(n) में scan करना, या HashSet की O(1) membership बनाम List की O(n)) और intent को प्रभावित करता है, इसलिए हर चीज़ के लिए List<T> पर default करने के बजाय उपयुक्त collection चुनना एक महत्वपूर्ण कौशल है।
ये collections generic (<T>) भी हैं, जो compile-time type safety प्रदान करती हैं।
safe dictionary lookups के लिए TryGetValue (गायब keys पर exceptions से बचना) और प्रत्येक type की performance characteristics जैसे व्यावहारिक विवरण जानना C# में data के साथ काम करने की रोजमर्रा की जरूरतों को कवर करता है।
चूंकि collections वस्तुतः हर program में आती हैं और सही choice performance व readability को सार्थक रूप से प्रभावित करती है, सामान्य collection types और उनके उचित उपयोग में महारत हासिल करना effective C# development के लिए आधारभूत, अवश्य-जानने योग्य ज्ञान है।