Generics memungkinkan Anda menulis kelas dan method yang diparameterisasi oleh tipe, memberikan type safety dan reusability tanpa duplikasi kode atau casting. Constraints membatasi tipe apa yang dapat digunakan oleh parameter generic, memungkinkan penggunaan member mereka dengan aman. Generics tersebar luas di C# (seluruh library collections menggunakannya).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generics memindahkan type error dari runtime (casting object) ke compile time, dan menghilangkan cast — kode yang aman dan dapat digunakan kembali.
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
Constraints (where T : ...) membatasi apa yang dapat menjadi T, yang memungkinkan Anda menggunakan member tipe tersebut dengan aman (misalnya constraining ke IComparable<T> memungkinkan Anda memanggil CompareTo). Tanpa constraint, T bisa apa saja, jadi Anda tidak dapat menganggap ada member apa pun.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Generics adalah fundamental untuk C# — mereka digunakan secara luas (seluruh library collections, Task<T>, IEnumerable<T>, dan API tak terhitung jumlahnya adalah generic), jadi memahami mereka sangat penting untuk pengembangan C# apa pun.
Generics menyelesaikan masalah nyata: menulis kode yang dapat digunakan kembali yang bekerja untuk banyak tipe sambil menjaga type safety — alternatifnya (menggunakan object dan casting) mengorbankan keamanan compile-time dan memerlukan cast yang rawan kesalahan, sementara menduplikasi kode per tipe tidak dapat dipertahankan.
Generics memberikan Anda kode yang dapat digunakan kembali dan type-safe tanpa casting dan pengecekan error compile-time. Constraints (where T : ...) adalah pelengkap penting: mereka membatasi apa yang dapat menjadi type parameter, yang memungkinkan penggunaan member tipe yang aman (constraining ke interface memungkinkan Anda memanggil methodnya) dan memastikan penggunaan yang benar.
Memahami generic classes dan methods, bagaimana type inference bekerja, dan constraints (class, struct, new(), interface/base-class constraints) diperlukan baik untuk menggunakan library .NET yang generic-heavy secara efektif maupun untuk menulis abstraksi Anda sendiri yang dapat digunakan kembali dan type-safe.
Karena generics mendasari collections C# dan banyak framework, dan karena mereka adalah kunci untuk kode yang dapat digunakan kembali dan type-safe, menguasai generics dan constraints adalah pengetahuan inti yang sering diterapkan untuk pengembangan C# yang efektif dan topik umum yang mencerminkan pemahaman desain yang type-safe dan dapat digunakan kembali.