C# System.Collections.Generic இல் ஒரு செழுமையான சேகரண வகைகளை வழங்குகிறது, இதில் தரவு குழுக்களை சேமிக்கப் பயன்படுகிறது. மிகவும் பொதுவானவை List<T> (dynamic array), Dictionary<K,V> (key-value map), மற்றும் HashSet<T> (unique 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> என்பது பொதுவுரை நோக்கத்திற்கான சேகரணம் — ஒரு 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> விசைகளை மதிப்புகளுடன் வேகமான O(1) lookups மூலம் மேப் செய்கிறது — caches, indexes, மற்றும் எந்த key-based access க்கும் பயன்படுகிறது. TryGetValue என்பது safe lookup செய்வதற்கான வழி (விசை காணப்படாத போது 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# இன் பொதுவான சேகரண வகைகளைப் புரிந்துகொள்ளுதல் மற்றும் நன்றாகத் தேர்ந்தெடுப்பது அপরिहार்य அன்றாட জ்ஞானமாகும்.
முக்கிய வகைகள் மற்றும் அவற்றின் பயன்பாட்டு நிலைகளை அறிவது — ordered, indexed, resizable data க்கு List<T> (பொதுவுரை workhorse), fast key-based lookup க்கு Dictionary<K,V> (caches, indexes), uniqueness மற்றும் fast membership tests க்கு HashSet<T>, மற்றும் FIFO/LIFO செயல்படுத்தலுக்கு Queue/Stack — திறமையான, தெளிவான குறியீட்டை எழுத அவசியம்.
தேர்வு நேரடியாக செயல்திறனை பாதிக்கிறது (எ.கா. Dictionary இன் O(1) lookup மற்றும் List இன் O(n) scanning, அல்லது HashSet இன் O(1) membership மற்றும் List இன் O(n)), மற்றும் நோக்கம், எனவே எல்லாவற்றிற்கும் List<T> க்கு இயல்பாக்குவதற்கு பதிலாக பொருத்தமான சேகரணத்தைத் தேர்ந்தெடுப்பது ஒரு முக்கியமான திறமையாகும்.
இந்தச் சேகரணங்கள் generic (<T>) ஆகும், compile-time type safety வழங்குகிறது.
TryGetValue இன் போன்ற நடைமுறை விபரங்களை அறிவது safe dictionary lookups க்கு (missing keys இல் exceptions தவிர்க்க) மற்றும் ஒவ்வொரு வகையின் செயல்திறன் பண்புகளை C# இல் தரவை உடன் பணிபுரிவதற்கான அன்றாட தேவைகளை உள்ளடக்குகிறது.
சேகரணங்கள் ஏறக்குறைய ஒவ்வொரு திட்டத்திலும் தோன்றுவதாலும் சரியான தேர்வு செயல்திறன் மற்றும் readability ஐ பொருளாக பாதிக்கிறது, பொதுவான சேகரண வகைகள் மற்றும் அவற்றின் பொருத்தமான பயன்பாடுகளில் தேர்ச்சி பெறுவது பயனுள்ள C# மேம்பாட்டுக்கு அடிப்படையான, தெரிந்தே கொள்ளப்பட வேண்டிய அறிவாகும்.
விரிவான பதில்களுடன் கூடிய IT நேர்காணல் கேள்விகளின் நூலகம் — Junior முதல் Senior வரை.
நன்கொடை