C# System.Collections.Genericలో డేటా సమూహాలను నిల్వ చేయడానికి సమృద్ధమైన సేకరణ రకాలను అందిస్తుంది. చాలా సాధారణమైనవి List<T> (డైనమిక్ శ్రేణి), Dictionary<K,V> (కీ-విలువ మ్యాప్), మరియు HashSet<T> (ప్రత్యేక సమితి). సరైన ఎంపికను ఎంచుకోవడం స్పష్టత మరియు పనితీరు కోసం ముఖ్యం.
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> ఒక జెనెరిక్ రకం పరామితి (List<string>, List<User>), కంపైల్-సమయం రకం సరితనను ఇస్తుంది.
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> కీలను విలువలకు వేగవంతమైన O(1) చేతనవేధం కలిగిన మ్యాప్ చేస్తుంది — క్యాష్ల కోసం, ఇండెక్సుల కోసం, మరియు ఏదైనా కీ-ఆధారిత ప్రాప్యత కోసం. TryGetValue సురక్షితమైన చేతనవేధం చేయడానికి సరైన మార్గం (కీ లేనప్పుడు మినహాయితను నివారించడం).
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#లోని సాధారణ సేకరణ రకాలను అర్థం చేసుకోవడం మరియు సరిగ్గా ఎంచుకోవడం అవసరమైన రోజువారీ జ్ఞానం.
ప్రధాన రకాలను మరియు వాటి ఉపయోగ సందర్భాలను తెలుసుకోవడం — List<T> ఆర్డర్ చేయబడిన, ఇండెక్స్ చేయబడిన, పరిమాణం మార్పుచేయుటకు సామర్థ్యమైన డేటా కోసం (సాధారణ-ప్రయోజన పనిగాడు), Dictionary<K,V> వేగవంతమైన కీ-ఆధారిత చేతనవేధం కోసం (క్యాష్లు, ఇండెక్సులు), HashSet<T> ప్రత్యేకత మరియు వేగవంతమైన సభ్యత్వ పరీక్షల కోసం, మరియు Queue/Stack FIFO/LIFO ప్రక్రియ కోసం — సమర్థవంతమైన, స్పష్టమైన కోడ్ను వ్రాయడానికి అవసరమైనది.
ఈ ఎంపిక నేరుగా పనితీరును ప్రభావితం చేస్తుంది (ఉదాహరణకు Dictionary యొక్క O(1) చేతనవేధం vs List యొక్క O(n) స్కానింగ్, లేదా HashSet యొక్క O(1) సభ్యత్వ vs List యొక్క O(n)) మరియు ఉద్దేశ్యం, కాబట్టి List<T>కు అన్నింటికీ డిఫాల్ట్ చేయడానికి బదులుగా తగిన సేకరణను ఎంచుకోవడం ఒక ముఖ్యమైన నైపుణ్యం.
ఈ సేకరణలు కూడా జెనెరిక్ (<T>), కంపైల్-సమయం రకం సరితనను అందిస్తుంది.
కీ-విలువ చేతనవేధాలకు TryGetValue వంటి ఆచరణాత్మక వివరాలను తెలుసుకోవడం (లేనివ్వని కీలపై మినహాయితలను నివారించడం) మరియు ప్రతి రకం యొక్క పనితీరు లక్షణాలు C#లో డేటా కార్యకలాపాల యొక్క రోజువారీ అవసరాలను కవర్ చేస్తాయి.
సేకరణలు దాదాపు ప్రతి ప్రోగ్రామ్లో కనిపించినందున మరియు సరైన ఎంపిక పనితీరు మరియు పఠనీయతను అర్థవంతంగా ప్రభావితం చేస్తుంది, సాధారణ సేకరణ రకాలు మరియు వాటి తగిన ఉపయోగాన్ని నిపుణత సాధించడం సమర్థవంతమైన C# అభివృద్ధికి ఆధారమైన, తప్పనిసరి జ్ఞానం.