X'inhuma l-generics u l-constraints?

Question

Accepted Answer

**Generics** jippermettulek tikteb klassijiet u metodi parametrizzati b'tip, u jipprovdu **sigurtà tat-tip u riutilizzabilità** mingħajr duplikazzjoni tal-kodiċi jew casting. **Constraints** jirristrinġu liema tipsi jista' jkun parametru generiku, u jippermettu l-użu sigur tal-membri tagħhom. Generics huma persistenti f'C# (il-librerija tas-collections kollha tuża tagħhom). ## Il-problema li l-generics isolvu ```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 ``` Generics iċċaqqu l-iżbalji tat-tip minn runtime (casting `object`) għal compile time, u jeliminaw il-casts — kodiċi sigur u riutilizzabbli. ## Klassijiet u metodi generici ```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; ``` ## Constraints — irristrinġi l-parametru tat-tip ```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 ``` **Constraints** (`where T : ...`) jirristrinġu liema ħaġa `T` tista' tkun, li jippermettulek tuża b'mod sigur il-membri ta' dak it-tip (pereż. jirristrinġi għal `IComparable` u tista' tkun tista' tkun takkja `CompareTo`). Mingħajr constraint, `T` tista' tkun kwalunkwe ħaġa, għalhekk ma tistax taħseb li għandha membri. ## Generics kullimkien f'.NET ```text List, Dictionary, IEnumerable, Task, Nullable ... → the entire collections library and much of .NET is generic. ``` ## Għaliex hija importanti Generics huma fundamentali għal C# — jintużaw b'mod wiesa' (il-librerija tas-collections kollha, `Task`, `IEnumerable`, u APIs inżejt huma generici), għalhekk il-fehim tagħhom huwa essenzjali għal kwalunkwe żvilupп C#. Generics isolvu problema reali: kitba ta' kodiċi riutilizzabbli li jaħdem għal tipsi multipli filwaqt li preserva **sigurtà tat-tip** — l-alternattiva (tuża `object` u casting) saċrifka l-sigurtà tal-compile-time u teħtieġ casts error-prone, filwaqt li d-duplikazzjoni tal-kodiċi għal tip huwa unmaintainable. Generics jagħtuk kodiċi riutilizzabbli u sigur tat-tip mingħajr casting u compile-time error checking. **Constraints** (`where T : ...`) huma komplementi importanti: jirristrinġu liema parametru tat-tip jista' jkun, u dan il-biss jippermettu l-użu sigur tal-membri tat-tip (jirristrinġu għal interface u tista' tkun takkja l-metodi tagħha) u jiggarantizzaw l-użu korrett. Il-fehim tal-klassijiet u metodi generici, kif jaħdem it-type inference, u constraints (`class`, `struct`, `new()`, interface/base-class constraints) huwa neċessarju għat-tuża tal-librerji generici-heavy ta' .NET b'mod effettiv u għal kitba tar-rikatti tiegħek tat-tip-safe u riutilizzabbli. Billi l-generics huma l-bazi tal-collections ta' C# u ħafna mill-framework, u billi huma l-ċavetta għal kodiċi tip-safe riutilizzabbli, il-mastering tal-generics u constraints huwa għarfien ċentrali u applikabbli tal-ħafna għall-żvilupп effettiv ta' C# u suġġett komuni li jirrifetti l-fehim ta' disinn tip-safe u riutilizzabbli.