C# System.Collections.Generic માં ડેટાના જૂથોને સંગ્રહ કરવા માટે સમૃદ્ધ સંગ્રહ પ્રકારો પ્રદાન કરે છે. સૌથી સામાન્ય છે List<T> (ગતિશીલ array), Dictionary<K,V> (key-value map), અને HashSet<T> (અનન્ય set). યોગ્ય પ્રકાર પસંદ કરવો સ્પષ્ટતા અને કર્મક્ષમતા માટે મહત્વપૂર્ણ છે.
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> એક સર્વોત્તમ સામાન્ય-હેતુ સંગ્રહ છે — એક ક્રમાંકિત, પુનઃસ્કેલ કરી શકાય તેવું, અનુક્રમિત સૂચી. <T> એક generic type પરિમાણ છે (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 સાથે fast O(1) lookups સાથે map કરે છે — caches, indexes, અને કોઈપણ key-based access માટે. TryGetValue lookup કરવાનો સુરક્ષિત તરીકો છે (જ્યારે 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[])
સંગ્રહો લગભગ દરેક પ્રોગ્રામ માટે મૌલિક છે — ડેટાના જૂથોને સંગ્રહ અને પ્રક્રિયા કરવું ક્રમાગત છે — તેથી C# ના સામાન્ય સંગ્રહ પ્રકારોને સમજવું અને સારી રીતે પસંદ કરવું આવશ્યક રોજિંદાનું જ્ઞાન છે.
મુખ્ય પ્રકારો અને તેમના use cases જાણવું — List<T> ક્રમાંકિત, અનુક્રમિત, પુનઃસ્કેલ કરી શકાય તેવા ડેટા માટે (સામાન્ય-હેતુ વર્કહોર્સ), Dictionary<K,V> fast key-based lookup માટે (caches, indexes), HashSet<T> uniqueness અને fast membership tests માટે, અને Queue/Stack FIFO/LIFO પ્રક્રિયા માટે — કાર્યક્ષમ, સ્પષ્ટ કોડ લખવા માટે જરૂરી છે.
પસંદ સીધી રીતે performance ને અસર કરે છે (દા.ત. Dictionary ની O(1) lookup વર્સેસ List ની O(n) scanning, અથવા HashSet ની O(1) membership વર્સેસ List ની O(n)) અને intent, તેથી બધા કાર્યોમાં List<T> ને ડિફોલ્ટ કરવાને બદલે યોગ્ય સંગ્રહ પસંદ કરવું એક મહત્વપૂર્ણ કૌશલ્ય છે.
ઐ સંગ્રહો પણ generic છે (<T>), compile-time type safety પ્રદાન કરતા.
TryGetValue જેવી વ્યવહારિક વિગતો જાણવી safe dictionary lookups માટે (missing keys પર exceptions ટાળવું) અને દરેક પ્રકારની performance ગુણવત્તાઓ C# માં ડેટાની સાથે કામ કરવાની રોજિંદાની જરૂરિયાતોને આવરી લે છે.
સંગ્રહો લગભગ દરેક પ્રોગ્રામમાં દેખાય છે અને યોગ્ય પસંદ performance અને readability ને અર્થપૂર્ણ રીતે અસર કરે છે, સામાન્ય સંગ્રહ પ્રકારોમાં માણસોનું અને તેમનો યોગ્ય ઉપયોગ માસ્ટર કરવું effective C# development માટે ভিत્તિ, જરૂર-જાણેલું જ્ઞાન છે.