Çfarë janë generikat dhe kufizimet?

Question

Accepted Answer

**Generikat** ju lejojnë të shkruani klasa dhe metoda të parametrizuara nga një tip, duke siguruar **siguri tipi dhe ripërdorim** pa duplikim kodi ose casting. **Kufizimet** kufizojnë se çfarë tipesh mund të jetë një parametër gjenerik, duke mundësuar përdorimin e sigurt të anëtarëve të tyre. Generikat janë të përhapura në C# (e gjithë biblioteka e koleksioneve i përdor ato). ## Problemi që zgjidhin generikat ```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 ``` Generikat zhvendosin gabimet e tipit nga runtime (casting i `object`) në compile time, dhe eliminojnë casting-et — kod i sigurt, i riplotësueshëm. ## Klasat dhe metodat gjenerike ```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; ``` ## Kufizimet — kufizoni parametrin e tipit ```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 ``` **Kufizimet** (`where T : ...`) kufizojnë se çfarë mund të jetë `T`, e cila ju lejon të përdorni në mënyrë të sigurt anëtarët e atij tipi (p.sh. kufizimi në `IComparable` ju lejon të thërrisni `CompareTo`). Pa një kufizim, `T` mund të jetë çdo gjë, kështu që nuk mund të supozoni asnjë anëtar. ## Generikat kudo në .NET ```text List, Dictionary, IEnumerable, Task, Nullable ... → the entire collections library and much of .NET is generic. ``` ## Pse ka rëndësi Generikat janë themelore për C# — ato përdoren në mënyrë të gjerë (e gjithë biblioteka e koleksioneve, `Task`, `IEnumerable`, dhe pafundësisht shumë API janë gjenerike), prandaj pra të kuptosh atyre është thelbësore për çdo zhvillim C#. Generikat zgjidhin një problem të vërtetë: shkruajnë kod të riplotësueshëm që funksionon për shumë tipa ndërsa ruan **siguri tipi** — alternativa (përdorimi i `object` dhe casting) sakrifikë siguri në compile-time dhe kërkon casting të rrezikshme me gabime, ndërsa duplikimi i kodit për secilin tip është i pamainteniushëm. Generikat ju japin kod të riplotësueshëm, të sigurt në tip pa casting dhe me kontroll gabimesh në compile-time. **Kufizimet** (`where T : ...`) janë një plotësim i rëndësishëm: ato kufizojnë se çfarë mund të jetë një parametër tipi, e cila si mundëson përdorimin e sigurt të anëtarëve të tipit (kufizimi në një ndërfaqe ju lejon të thërrisni metodat e saj) dhe siguron përdorimin e saktë. Përkuptimi i klasave dhe metodave gjenerike, si funksionon përfundimi i tipit, dhe kufizimet (`class`, `struct`, `new()`, kufizimet e ndërfaqes/klasa bazë) është i nevojshëm si për përdorimin efektiv të bibliotekave .NET të mbushura me gjenerika ashtu edhe për shkrimin e përshtatjeve tuaja të tyre të riplotësueshme, të sigurta në tip. Sepse generikat janë bazë në koleksionet e C# dhe në shumicën e framework-ut, dhe sepse ato janë çelësi për kod të riplotësueshëm e të sigurt në tip, përvetësimi i gjenerikateve dhe kufizimeve është njohje thelbësore, e përdorur shpesh për zhvillim efektiv të C# dhe një temë e zakonshme që pasqyron kuptimin e dizajnit të sigurt për tip dhe të riplotësueshëm.