Generik membolehkan anda menulis kelas dan kaedah yang diparameterkan mengikut jenis, menyediakan keselamatan jenis dan kebolehgunaan semula tanpa pertindihan kod atau casting. Kekangan menyekat jenis apa yang boleh menjadi parameter generik, membolehkan penggunaan ahlinya dengan selamat. Generik berleluasa dalam C# (keseluruhan perpustakaan koleksi menggunakannya).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generik memindahkan ralat jenis daripada masa jalan (casting object) kepada masa kompilasi, dan menghapuskan cast — kod yang selamat dan boleh diguna semula.
public class Box<T> // a generic class
{
private T _value;
public void Set(T value) => _value = value;
public T Get() => _value;
}
var box = new Box<string>(); // T = string, type-safe
// generic method
public T Max<T>(T a, T b) where T : IComparable<T> // constraint (see below)
=> a.CompareTo(b) > 0 ? a : b;
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> // 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>(T a, T b) where T : IComparable<T>
=> a.CompareTo(b) > 0 ? a : b; // CompareTo is available because of the constraint
Kekangan (where T : ...) menyekat apa yang boleh menjadi T, yang membolehkan anda menggunakan ahli jenis tersebut dengan selamat (cth. mengekang kepada IComparable<T> membolehkan anda memanggil CompareTo). Tanpa kekangan, T boleh menjadi apa-apa sahaja, jadi anda tidak boleh menganggap sebarang ahli.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Generik adalah asas kepada C# — ia digunakan secara berleluasa (keseluruhan perpustakaan koleksi, Task<T>, IEnumerable<T>, dan tidak terkira banyaknya API adalah generik), jadi memahaminya adalah penting untuk sebarang pembangunan C#.
Generik menyelesaikan masalah sebenar: menulis kod boleh guna semula yang berfungsi untuk berbilang jenis sambil mengekalkan keselamatan jenis — alternatifnya (menggunakan object dan casting) mengorbankan keselamatan masa kompilasi dan memerlukan cast yang terdedah kepada ralat, manakala menduplikasi kod bagi setiap jenis tidak boleh diselenggara.
Generik memberikan anda kod yang boleh diguna semula, selamat jenis, tanpa casting dan dengan pemeriksaan ralat masa kompilasi. Kekangan (where T : ...) ialah pelengkap penting: ia menyekat apa yang boleh menjadi parameter jenis, yang kedua-duanya membolehkan penggunaan ahli jenis tersebut dengan selamat (mengekang kepada interface membolehkan anda memanggil kaedahnya) dan memastikan penggunaan yang betul.
Memahami kelas dan kaedah generik, cara inferens jenis berfungsi, dan kekangan (class, struct, new(), kekangan interface/kelas-asas) adalah perlu untuk kedua-dua menggunakan perpustakaan .NET yang banyak generik dengan berkesan dan menulis abstraksi anda sendiri yang boleh diguna semula serta selamat jenis.
Memandangkan generik mendasari koleksi C# dan kebanyakan rangka kerja, dan memandangkan ia ialah kunci kepada kod selamat jenis yang boleh diguna semula, menguasai generik dan kekangan ialah pengetahuan teras yang kerap diterapkan untuk pembangunan C# yang berkesan dan topik biasa yang mencerminkan pemahaman tentang reka bentuk yang selamat jenis dan boleh diguna semula.