Generic கள் மற்றும் Constraint கள் என்ன?

Question

Accepted Answer

**Generic கள்** என்பவை வகையால் parameterized செய்யப்பட்ட வகுப்புகள் மற்றும் முறைகளை எழுத உங்களை அனுமதிக்கின்றன, **வகை பாதுகாப்பு மற்றும் மறுபயன்பாடு** வழங்குகின்றன - குறியீட்டு நகலெடுப்பு அல்லது வெளிப்படுத்தல் இல்லாமல். **Constraint கள்** என்பவை generic parameter கள் என்ன வகையாக இருக்கலாம் என்பதைக் கட்டுப்படுத்துகின்றன, அவற்றின் உறுப்பினர்களை பாதுகாப்பாகப் பயன்படுத்த உதவுகின்றன. Generic கள் C# இல் எங்கும் உள்ளன (முழு collections library அவற்றைப் பயன்படுத்துகிறது). ## Generic கள் தீர்க்கும் சிக்கல் ```csharp // without generics — either duplicate per type, or use `object` (unsafe, requires casts) object Get(object[] arr, int i) => arr[i]; // returns object → cast needed, runtime errors // with generics — type-safe and reusable T Get(T[] arr, int i) => arr[i]; // works for any T, returns the exact type int x = Get(new[] { 1, 2, 3 }, 0); // T inferred as int, no cast ``` Generic கள் வகை பிழைகளை runtime இலிருந்து (object ஐ வெளிப்படுத்துதல்) compile time க்கு நகர்த்துகின்றன, மேலும் வெளிப்படுத்தல்களை நீக்குகின்றன — பாதுகாப்பான, மறுபயன்படுத்தக்கூடிய குறியீடு. ## Generic வகுப்புகள் மற்றும் முறைகள் ```csharp public class Box // a generic class { private T _value; public void Set(T value) => _value = value; public T Get() => _value; } var box = new Box(); // T = string, type-safe // generic method public T Max(T a, T b) where T : IComparable // constraint (see below) => a.CompareTo(b) > 0 ? a : b; ``` ## Constraint கள் — வகை parameter ஐ கட்டுப்படுத்தவும் ```csharp where T : class // T must be a reference type where T : struct // T must be a value type where T : new() // T must have a parameterless constructor where T : IComparable // T must implement an interface (so you can call its members) where T : BaseClass // T must derive from BaseClass // example: constraint lets you call CompareTo safely public T Max(T a, T b) where T : IComparable => a.CompareTo(b) > 0 ? a : b; // CompareTo is available because of the constraint ``` **Constraint கள்** (`where T : ...`) என்பவை `T` என்ன இருக்கலாம் என்பதைக் கட்டுப்படுத்துகின்றன, இது அந்த வகையின் உறுப்பினர்களை பாதுகாப்பாகப் பயன்படுத்த உங்களை அனுமதிக்கிறது (எ.கா. `IComparable` க்கு கட்டுப்படுத்தல் `CompareTo` ஐ அழைக்க உங்களை அனுமதிக்கிறது). constraint இல்லாமல், `T` எதுவும் இருக்கலாம், எனவே நீங்கள் எந்த உறுப்பினர்களையும் கருதினால் சாத்தியமில்லை. ## .NET ல் Generic கள் எங்கும் உள்ளன ```text List, Dictionary, IEnumerable, Task, Nullable ... → the entire collections library and much of .NET is generic. ``` ## ஏன் இது முக்கியம் Generic கள் C# க்கு அடிப்படை — அவை எங்கும் பயன்படுத்தப்படுகின்றன (முழு collections library, `Task`, `IEnumerable`, மற்றும் எண்ணற்ற API கள் generic ஆக இருக்கின்றன), எனவே அவற்றைப் புரிந்துகொள்வது எந்த C# development க்கும் அத்यாவசியம். Generic கள் ஒரு உண்மையான சிக்கலைத் தீர்க்கின்றன: பல வகைகளுக்குப் பணிபுரியும் மறுபயன்படுத்தக்கூடிய குறியீடு எழுதுதல் - **வகை பாதுகாப்பு** பராமரிக்கையில் — மாற்று (`object` ஐப் பயன்படுத்தி வெளிப்படுத்தல்) compile-time பாதுகாப்பை பலிசெய்கிறது மற்றும் பிழை-முனை வெளிப்படுத்தல்களைத் தேவைப்படுத்துகிறது, அதேசமயம் வகைக்கு per குறியீட்டு நகலெடுப்பு பராமரிக்க முடியாதது. Generic கள் உங்களுக்கு மறுபயன்படுத்தக்கூடிய, வகை-பாதுகாப்பான குறியீடு வழங்குகின்றன - வெளிப்படுத்தல் இல்லாமல் மற்றும் compile-time பிழை சரிபார்ப்பு. **Constraint கள்** (`where T : ...`) ஒரு முக்கியமான நிரப்பு: அவை வகை parameter என்ன இருக்கலாம் என்பதைக் கட்டுப்படுத்துகின்றன, இது வகையின் உறுப்பினர்களை பாதுகாப்பாகப் பயன்படுத்த உதவுகிறது (interface க்கு constraining அதன் முறைகளை அழைக்க உங்களை அனுமதிக்கிறது) மற்றும் சரியான பயன்பாட்டை உறுதিசெய்கிறது. Generic வகுப்புகள் மற்றும் முறைகள், வகை inference எவ்வாறு செயல்படுகிறது, மற்றும் constraint கள் (`class`, `struct`, `new()`, interface/base-class constraints) ஆகியவற்றைப் புரிந்துகொள்வது — generic-heavy .NET libraries ஐ திறம்பட பயன்படுத்தவும் உங்கள் சொந்த மறுபயன்படுத்தக்கூடிய, வகை-பாதுகாப்பான abstractions எழுதவும் இரண்டுமே அவசியம். Generic கள் C# இன் collections ஐ அடிப்படையாகக் கொண்டிருப்பதால் மற்றும் framework இன் பெரும்பகுதி, மற்றும் அவை மறுபயன்படுத்தக்கூடிய வகை-பாதுகாப்பான குறியீடுக்கான முறை — generic கள் மற்றும் constraint கள் நன்கு புரிந்துகொள்வது core, அடிக்கடி-பயன்படுத்தப்படும் திறம்பட C# development மற்றும் வகை-பாதுகாப்பான, மறுபயன்படுத்தக்கூடிய வடிவமைப்பு புரிந்துகொள்வதை பிரதிபலிக்கும் ஒரு பொதுவான தலைப்பு.