Bagian 1: Pendahuluan

Hampir setiap developer .NET mungkin pernah menuliskan kode seperti ini tanpa perlu terlalu memikirkan apa yang terjadi di baliknya:

List<string> names = new List<string>();
Dictionary<int, string> users = new Dictionary<int, string>();
Task<int> result = GetDataAsync();

Tanda <T> yang sering muncul dalam kode C# bukan sekadar bagian dari sintaks. Tanda tersebut berkaitan dengan Generic, salah satu fitur fundamental dalam C# yang digunakan di berbagai bagian .NET.

Beberapa contoh yang paling mudah ditemui antara lain:

• List<T> — koleksi dinamis yang dapat digunakan untuk berbagai tipe data

• Dictionary<TKey, TValue> — struktur data key-value dengan tipe data yang jelas

• IEnumerable<T> — salah satu fondasi penting dalam LINQ

• Task<T> — representasi hasil dari operasi asynchronous

• Nullable<T> — memungkinkan value type seperti int atau bool memiliki nilai null

Ada satu hal yang sama dari semua contoh tersebut: tipe data tidak ditentukan ketika class atau interface dibuat, tetapi ditentukan ketika digunakan.

Sebagai contoh, List<T> dapat digunakan untuk berbagai kebutuhan:

List<int> numbers = new List<int>();
List<string> names = new List<string>();
List<Product> products = new List<Product>();

Tidak perlu membuat IntegerList, StringList, dan ProductList secara terpisah. Satu implementasi List<T> dapat digunakan untuk berbagai tipe data.

Lalu muncul pertanyaan sederhana: mengapa banyak collection di .NET menggunakan Generic?

Jawabannya berkaitan dengan dua kebutuhan penting dalam pengembangan software: type safety dan code reusability.

Sebelum Generic digunakan secara luas, mendapatkan keduanya sekaligus tidak selalu mudah. Salah satu pendekatan adalah membuat class yang berbeda untuk setiap tipe data. Cara ini memang memberikan type safety, tetapi menghasilkan banyak kode yang sebenarnya memiliki logika hampir sama.

Pendekatan lainnya adalah menggunakan object sehingga satu class dapat menerima berbagai tipe data:

List<object> values = new List<object>();

values.Add(10);
values.Add("Hello");
values.Add(new Product());

Cara tersebut memang lebih fleksibel, tetapi tipe data menjadi kurang jelas. Nilai yang diambil dari collection juga sering kali perlu dikonversi kembali ke tipe yang diharapkan. Kesalahan tipe baru dapat diketahui ketika program berjalan.

Generic menawarkan pendekatan yang lebih praktis. Tipe data tidak perlu ditentukan secara hardcode di dalam class, tetapi dapat diberikan sebagai parameter tipe.

Konsepnya mirip dengan method yang menerima parameter berupa nilai:

void Print(string message)
{
    // ...
}

Method tersebut menerima message sebagai parameter. Generic menggunakan ide yang serupa, tetapi parameter yang diberikan adalah tipe data:

class Box<T>
{
    public T Value { get; set; }
}

Saat class digunakan, tipe T dapat ditentukan:

Box<int> numberBox = new Box<int>();
Box<string> textBox = new Box<string>();

Dengan pendekatan ini, satu class dapat digunakan untuk berbagai tipe data sekaligus tetap memberikan pemeriksaan tipe oleh compiler. Melalui memahami konsep tersebut, Generic tidak lagi sekadar terlihat sebagai tanda <T> yang muncul di berbagai bagian kode C#. Generic dapat dipahami sebagai cara untuk membuat kode yang dapat digunakan kembali, tetap type-safe, dan fleksibel terhadap berbagai tipe data.

Sebelum masuk ke definisi Generic secara formal, ada baiknya melihat terlebih dahulu bagaimana masalah yang sama biasanya diselesaikan sebelum Generic digunakan di C#. Dengan memahami masalah tersebut, alasan dan manfaat penggunaan Generic akan lebih mudah terlihat.

Bagian 2: Masalah Sebelum Generic

Sebelum Generic diperkenalkan di C# 2.0 pada tahun 2005, salah satu cara untuk membuat collection yang dapat menyimpan berbagai jenis data adalah menggunakan object sebagai tipe dasarnya. Salah satu contoh yang cukup terkenal adalah ArrayList.

ArrayList dapat menyimpan berbagai macam tipe data dalam satu collection. Di balik layar, setiap nilai yang dimasukkan akan diperlakukan sebagai object. Sekilas, pendekatan ini terlihat praktis. Satu collection bisa menyimpan angka, teks, bahkan object dari class yang berbeda. Namun, ada beberapa konsekuensi yang baru terlihat ketika data tersebut mulai digunakan kembali.

Contoh Kode: ArrayList

Berikut contoh sederhana penggunaan ArrayList:

using System.Collections;

ArrayList list = new ArrayList();

list.Add(10);
list.Add("dua puluh");
list.Add(30.5);

foreach (var item in list)
{
    Console.WriteLine(item);
}

Kode tersebut dapat berjalan tanpa masalah. ArrayList menerima int, string, dan double dalam collection yang sama. Masalahnya muncul ketika data tersebut diproses dengan asumsi tipe tertentu. Misalnya, seluruh isi collection dianggap sebagai angka:

int total = 0;

foreach (var item in list)
{
    total += (int)item;
}

Kode tersebut tetap berhasil dikompilasi. Namun, ketika program berjalan dan mencapai nilai "dua puluh", program akan gagal dengan InvalidCastException. Alasannya sederhana: "dua puluh" adalah string, sedangkan kode mencoba mengubahnya menjadi int. Di sinilah salah satu kelemahan utama ArrayList terlihat. Compiler tidak memiliki informasi yang cukup untuk memastikan tipe data setiap elemen. Semua elemen hanya terlihat sebagai object. Akibatnya, kesalahan seperti ini baru diketahui ketika program dijalankan, bukan ketika kode dikompilasi.

Idealnya, kesalahan tipe data dapat diketahui sedini mungkin. Semakin awal sebuah kesalahan ditemukan, semakin mudah pula memperbaikinya. Jika kesalahan baru muncul ketika aplikasi sedang digunakan, dampaknya tentu bisa menjadi lebih besar.

Boxing dan Unboxing

Selain masalah type safety, penggunaan object juga membawa konsekuensi lain, terutama ketika collection menyimpan value type seperti int, double, atau bool. Di sinilah istilah boxing dan unboxing mulai muncul. Boxing adalah proses ketika sebuah value type dikonversi menjadi object. Sebaliknya, unboxing adalah proses mengambil kembali value type dari object.

Contohnya:

int number = 10;

object boxed = number;       // boxing
int unboxed = (int)boxed;    // unboxing

Pada saat number dimasukkan ke dalam object, nilai int tersebut perlu dibungkus menjadi sebuah object. Proses inilah yang disebut boxing. Ketika nilai tersebut ingin digunakan kembali sebagai int, diperlukan proses unboxing.

Secara sederhana, gambaran prosesnya seperti ini:

int
 │
 │ boxing
 ▼
object
 │
 │ unboxing
 ▼
int

Untuk satu atau dua nilai, overhead tersebut mungkin tidak terlalu terasa. Namun, jika proses yang sama terjadi dalam jumlah besar dan berulang, alokasi object tambahan dan pekerjaan garbage collector dapat ikut memengaruhi performa.

Misalnya, sebuah collection berisi ribuan atau bahkan jutaan angka. Jika setiap angka harus melalui proses boxing ketika dimasukkan ke collection, akan ada lebih banyak object yang perlu dialokasikan dan nantinya dikelola oleh garbage collector.

Ini bukan berarti setiap penggunaan object atau boxing otomatis menyebabkan masalah performa. Dalam banyak kasus, dampaknya kecil. Namun, pada operasi yang sangat sering atau pemrosesan data dalam jumlah besar, overhead tersebut dapat menjadi pertimbangan penting.

Pembahasan mengenai value type, reference type, boxing, dan unboxing secara lebih mendalam dapat dilihat pada artikel Mengupas Value Type dan Reference Type di C#.

Casting yang Berlebihan

Masalah lain muncul ketika nilai dari ArrayList ingin digunakan kembali. Karena setiap elemen dianggap sebagai object, compiler tidak mengetahui tipe asli dari nilai tersebut.

Misalnya:

string name = (string)list[1];
double price = (double)list[2];

Casting seperti ini diperlukan agar nilai object dapat digunakan sebagai tipe yang diharapkan. Masalahnya, casting juga menjadi tanggung jawab kode yang menggunakan collection. Jika tipe sebenarnya tidak sesuai dengan tipe yang digunakan dalam casting, program dapat mengalami InvalidCastException ketika berjalan.

Contohnya:

ArrayList list = new ArrayList();

list.Add(100);

string value = (string)list[0];

Nilai 100 sebenarnya adalah int, tetapi kode mencoba melakukan casting menjadi string. Compiler tidak dapat mendeteksi kesalahan tersebut karena dari sudut pandangnya, list[0] memang bertipe object. Kesalahan baru terlihat saat program dijalankan. Semakin sering casting seperti ini dilakukan, semakin besar pula kemungkinan terjadi kesalahan tipe data.

Dari sini terlihat bahwa pendekatan berbasis object memang memberikan fleksibilitas, tetapi harus dibayar dengan beberapa konsekuensi:

• Type safety berkurang karena compiler tidak mengetahui tipe elemen sebenarnya.

• Casting menjadi lebih sering karena nilai harus dikembalikan ke tipe aslinya secara manual.

• Kesalahan tipe dapat muncul saat runtime, misalnya melalui InvalidCastException.

• Value type dapat mengalami boxing dan unboxing, yang menambah overhead tertentu.

• Kode menjadi lebih sulit dipahami, karena tipe data tidak terlihat dengan jelas dari deklarasi collection.

Lalu muncul kebutuhan yang cukup jelas: bagaimana jika sebuah collection tetap dapat digunakan untuk berbagai tipe data, tetapi compiler juga mengetahui tipe data tersebut sejak awal?

Misalnya, daripada menggunakan:

ArrayList numbers = new ArrayList();

dan kemudian harus melakukan casting:

int number = (int)numbers[0];

akan jauh lebih nyaman jika tipe datanya sudah diketahui sejak collection dibuat:

List<int> numbers = new List<int>();

int number = numbers[0];

Pada contoh terakhir, List<int> memberi tahu compiler bahwa collection tersebut hanya berisi int. Tidak diperlukan casting ketika mengambil nilainya, dan compiler juga dapat menolak data dengan tipe yang tidak sesuai. Inilah masalah yang kemudian dijawab oleh Generic.

Bagian 3: Apa Itu Generic?

Setelah melihat beberapa masalah pada ArrayList dan penggunaan object, sekarang saatnya melihat pendekatan yang digunakan C# untuk mengatasinya: Generic. Secara sederhana, Generic adalah cara membuat class, method, interface, atau struct yang dapat bekerja dengan berbagai tipe data tanpa harus menentukan tipe tersebut secara langsung ketika kode dibuat. Tipe data tersebut nantinya diberikan ketika kode digunakan.

Konsepnya mirip dengan parameter pada method. Sebuah method dapat menerima nilai sebagai parameter:

void Print(string message)
{
    Console.WriteLine(message);
}

message merupakan parameter yang nilainya baru diketahui ketika method dipanggil.

Generic menggunakan konsep yang serupa, tetapi parameter yang diberikan bukan nilai, melainkan tipe data.

Contoh Sederhana: Class Box<T>

Berikut contoh class sederhana menggunakan Generic:

public class Box<T>
{
    public T Value { get; set; }
}

T pada Box<T> disebut type parameter.

Type parameter dapat dianggap sebagai tempat untuk menyimpan informasi tentang tipe data yang akan digunakan nanti. Huruf T sendiri bukan kata khusus yang diwajibkan oleh C#. T hanyalah konvensi penamaan yang umum digunakan karena berasal dari kata Type.

Nama lain juga diperbolehkan:

public class Box<TItem>
{
    public TItem Value { get; set; }
}

Secara konsep, Box<T> dan Box<TItem> bekerja dengan cara yang sama. Saat class tersebut digunakan, tipe data ditentukan di antara tanda < dan >:

Box<int> intBox = new Box<int>();
intBox.Value = 100;

Box<string> stringBox = new Box<string>();
stringBox.Value = "Halo Generic";

Console.WriteLine(intBox.Value);     // Output: 100
Console.WriteLine(stringBox.Value);  // Output: Halo Generic

Pada Box<int>, T menjadi int. Sedangkan pada Box<string>, T menjadi string. Dengan demikian, satu definisi class dapat digunakan untuk berbagai tipe data.

Secara sederhana, hubungan tersebut dapat digambarkan seperti ini:

                 Box<T>
                   │
          ┌────────┴────────┐
          │                 │
       Box<int>         Box<string>
          │                 │
       Value: int       Value: string

Tidak perlu membuat class terpisah seperti IntBox dan StringBox. Cukup ada satu Box<T>, lalu tipe data ditentukan ketika class tersebut digunakan.

Type Safety Tetap Terjaga

Salah satu manfaat penting Generic adalah compiler tetap mengetahui tipe data yang digunakan.

Misalnya:

Box<int> intBox = new Box<int>();

intBox.Value = 100;

Karena intBox merupakan Box<int>, compiler mengetahui bahwa property Value bertipe int. Jika ada nilai dengan tipe yang tidak sesuai:

Box<int> intBox = new Box<int>();

intBox.Value = "ini string";

Kode tersebut akan menghasilkan compile error.

Kesalahan dapat diketahui sebelum program dijalankan karena compiler sudah mengetahui bahwa Value hanya menerima int.

Hal yang sama berlaku untuk Box<string>:

Box<string> stringBox = new Box<string>();

stringBox.Value = "Hello";

Kode tersebut valid karena Value pada instance tersebut bertipe string. Perbedaan ini cukup penting jika dibandingkan dengan pendekatan menggunakan object.

Pada ArrayList, compiler hanya mengetahui bahwa setiap elemen bertipe object:

ArrayList list = new ArrayList();

list.Add(100);

int number = (int)list[0];

Developer perlu memastikan sendiri bahwa nilai yang diambil memang dapat di-cast menjadi int.

Dengan Generic, informasi tipe tersebut sudah menjadi bagian dari definisi collection:

List<int> numbers = new List<int>();

numbers.Add(100);

int number = numbers[0];

Tidak diperlukan casting karena compiler sudah mengetahui bahwa numbers hanya berisi int.

Bagaimana dengan T?

Pada saat menulis class:

public class Box<T>
{
    public T Value { get; set; }
}

T belum mewakili tipe tertentu.

Tipe tersebut baru ditentukan ketika Generic digunakan:

Box<int> intBox = new Box<int>();
Box<string> stringBox = new Box<string>();

Setelah Box<int> digunakan, compiler dan runtime memperlakukan Value sebagai int untuk instance tersebut. Sementara pada Box<string>, Value bertipe string.

Hal pentingnya adalah informasi tipe tetap dipertahankan sepanjang penggunaan Generic tersebut. Compiler dapat menggunakan informasi ini untuk melakukan pemeriksaan tipe dan memberikan bantuan seperti IntelliSense.

Inilah yang membuat Generic berbeda dari sekadar menggunakan object.

Dengan object, tipe data yang sebenarnya dapat menjadi tidak jelas:

object value = 100;

int number = (int)value;

Dengan Generic, tipe data menjadi bagian dari tipe itu sendiri:

Box<int> box = new Box<int>();

int number = box.Value;

Bukan Hanya untuk Class

Generic tidak hanya dapat digunakan pada class.

Konsep yang sama juga tersedia pada:

• Method — membuat method yang dapat bekerja dengan berbagai tipe data

• Interface — membuat kontrak yang tetap type-safe untuk berbagai tipe

• Struct — membuat value type yang dapat bekerja dengan tipe data tertentu

• Delegate — memungkinkan delegate bekerja dengan parameter dan return type yang bersifat Generic

Contohnya, Generic method dapat ditulis seperti ini:

public static T GetValue<T>(T value)
{
    return value;
}

Method tersebut dapat digunakan dengan berbagai tipe:

int number = GetValue(100);
string text = GetValue("Hello");
bool status = GetValue(true);

Dalam contoh tersebut, compiler dapat menentukan tipe T berdasarkan argument yang diberikan. Konsep dasarnya tetap sama: tipe data dijadikan sebagai parameter. Dengan pendekatan ini, satu definisi kode dapat digunakan untuk berbagai tipe data tanpa harus membuat implementasi yang sama berulang kali.

Lebih penting lagi, fleksibilitas tersebut tetap disertai dengan type safety. Compiler mengetahui tipe yang digunakan dan dapat mendeteksi banyak kesalahan sebelum program dijalankan.

Bagian 4: Mengapa Generic Lebih Baik?

Setelah melihat cara kerja Generic secara mendasar, pertanyaan berikutnya adalah: mengapa Generic banyak digunakan di .NET?

Jawabannya bukan hanya karena sintaksnya lebih ringkas. Generic membantu menyelesaikan beberapa masalah yang muncul ketika kode harus bekerja dengan berbagai tipe data, terutama masalah type safety, casting, penggunaan ulang kode, dan dalam kondisi tertentu, performa.

Type Safety

Type safety berarti compiler dapat memeriksa apakah tipe data yang digunakan sudah sesuai dengan aturan yang ditentukan dalam kode.

Misalnya, sebuah collection memang dirancang untuk menyimpan angka int. Idealnya, string atau tipe data lain tidak dapat dimasukkan ke dalam collection tersebut secara tidak sengaja.

Sebelum Generic, pendekatan berbasis ArrayList memungkinkan berbagai tipe data masuk ke dalam collection yang sama:

ArrayList list = new ArrayList();

list.Add(10);
list.Add("dua puluh");

Tidak ada error pada saat kode dikompilasi. Kedua nilai tersebut diterima karena ArrayList menyimpan elemen sebagai object. Masalah baru muncul ketika seluruh isi collection kemudian diperlakukan sebagai int.

Dengan Generic, tipe data dapat ditentukan sejak awal:

List<int> list = new List<int>();

list.Add(10);
list.Add("dua puluh");

Pada contoh ini, baris kedua akan menghasilkan compile error. List<int> sudah secara jelas menyatakan bahwa collection tersebut hanya dapat menyimpan nilai bertipe int.

Kesalahan tipe data yang sebelumnya mungkin baru diketahui ketika aplikasi berjalan, sekarang dapat ditemukan lebih awal.

Compile-Time Checking

Generic bekerja bersama compiler untuk melakukan pemeriksaan tipe sebelum program dijalankan. Proses ini dikenal sebagai compile-time checking.

Misalnya:

List<int> numbers = new List<int>();

numbers.Add(10);
numbers.Add(20);
numbers.Add("tiga puluh");

Compiler dapat langsung mengetahui bahwa "tiga puluh" tidak sesuai dengan tipe int. Error dapat ditemukan saat proses penulisan atau build kode, tanpa harus menunggu aplikasi dijalankan.

Hal ini berbeda dengan pendekatan berbasis object, di mana banyak kesalahan tipe baru terlihat ketika sebuah nilai di-cast:

object value = "Hello";

int number = (int)value;

Kode tersebut dapat dikompilasi, tetapi akan gagal ketika dijalankan.

Semakin banyak kesalahan yang dapat ditemukan pada tahap compile-time, semakin kecil kemungkinan kesalahan tipe data tersebut muncul ketika aplikasi sudah berjalan.

Generic tidak dapat mencegah semua jenis bug, tentu saja. Namun, Generic memberikan compiler lebih banyak informasi tentang tipe data yang digunakan sehingga lebih banyak kesalahan dapat dideteksi sejak awal.

Code Reusability

Keuntungan lain dari Generic adalah kemampuan untuk menggunakan kembali kode yang sama untuk berbagai tipe data. Tanpa Generic, sebuah class yang memiliki logika serupa untuk beberapa tipe data biasanya membutuhkan implementasi terpisah atau menggunakan object.

Misalnya, sebuah repository sederhana dapat dibuat menggunakan Generic:

public class Repository<T>
{
    private List<T> _items = new List<T>();

    public void Add(T item)
    {
        _items.Add(item);
    }
}

Class tersebut dapat digunakan untuk berbagai tipe:

Repository<Product> productRepository = new Repository<Product>();

Repository<Customer> customerRepository = new Repository<Customer>();

Satu Repository<T> dapat digunakan untuk Product, Customer, atau tipe lainnya.

Tidak perlu menulis ulang logika yang sama:

ProductRepository
CustomerRepository
OrderRepository

selama perbedaan antar repository hanya terletak pada tipe data yang dikelola.

Dengan Generic, kode yang memiliki pola atau perilaku sama dapat ditulis sekali dan digunakan kembali untuk berbagai tipe.

Performa

Generic juga dapat memberikan keuntungan dari sisi performa, terutama ketika bekerja dengan value type seperti int, double, atau struct. Seperti yang sudah dibahas sebelumnya, collection lama seperti ArrayList menyimpan elemen sebagai object.

Ketika sebuah int dimasukkan ke dalam ArrayList, terjadi proses boxing:

ArrayList list = new ArrayList();

list.Add(10);

Secara konsep, nilai tersebut harus diperlakukan sebagai object agar dapat disimpan di dalam collection. Ketika nilainya diambil kembali sebagai int, proses unboxing diperlukan:

int number = (int)list[0];

Pada Generic, tipe data sudah diketahui:

List<int> numbers = new List<int>();

numbers.Add(10);

int number = numbers[0];

List<int> menyimpan dan mengembalikan nilai sebagai int, sehingga penggunaan value type dalam collection seperti ini tidak memerlukan boxing dan unboxing seperti pada ArrayList.

Perbedaan tersebut mungkin tidak terasa untuk beberapa data saja. Namun, pada operasi yang dilakukan berulang kali atau pemrosesan data dalam jumlah besar, berkurangnya alokasi dan proses tambahan dapat memberikan keuntungan pada penggunaan memori dan performa.

Karena itu, Generic bukan sekadar fitur untuk membuat kode terlihat lebih rapi. Pada kasus tertentu, Generic juga dapat membantu menghasilkan kode yang lebih efisien.

Mengurangi Casting

Pada ArrayList, setiap nilai yang diambil memiliki tipe object. Akibatnya, casting biasanya diperlukan:

ArrayList list = new ArrayList();

list.Add("Andi");

string name = (string)list[0];

Dengan Generic, tipe data hasil sudah diketahui:

List<string> names = new List<string>();

names.Add("Andi");

string name = names[0];

Tidak diperlukan (string) karena names[0] memang sudah diketahui bertipe string. Selain membuat kode lebih ringkas, berkurangnya casting juga mengurangi kemungkinan terjadinya kesalahan seperti:

string name = (string)someObject;

ketika someObject ternyata bukan string.

Informasi tipe sudah tersedia sejak awal dan dapat diperiksa oleh compiler.

Ringkasan Perbandingan

Perbedaan antara pendekatan berbasis ArrayList atau object dan Generic dapat diringkas seperti berikut:

Semua keuntungan tersebut saling berkaitan. Type safety membantu mengurangi kesalahan penggunaan tipe data. Compile-time checking membantu menemukan kesalahan lebih awal. Generic juga memungkinkan kode dengan logika yang sama digunakan kembali untuk berbagai tipe, sehingga duplikasi dapat dikurangi.

Di sisi lain, ketika digunakan dengan tepat, Generic juga dapat menghindari overhead seperti boxing dan unboxing pada value type. Kombinasi inilah yang membuat Generic menjadi salah satu fondasi penting dalam library modern .NET.

Bagian 5: Generic Class

Setelah melihat contoh sederhana seperti Box<T>, sekarang saatnya melihat Generic Class dalam contoh yang lebih dekat dengan kebutuhan aplikasi.

Salah satu contoh yang mudah digunakan untuk memahami konsep ini adalah Repository<T>.

Repository pada contoh ini bertugas menyimpan dan mengelola sekumpulan data. Karena logika yang dibutuhkan cukup umum, tipe data yang dikelola dapat dijadikan sebagai parameter Generic.

Studi Kasus: Repository<T>

Bayangkan sebuah aplikasi yang memiliki beberapa jenis entitas:

• Product

• Customer

• Order

Masing-masing entitas tentu memiliki data yang berbeda. Namun, beberapa operasi dasarnya bisa saja sama, misalnya:

• menambahkan data

• menghapus data

• mencari data

• mengambil seluruh data

Tanpa Generic, bisa saja dibuat repository terpisah untuk setiap entitas:

ProductRepository
CustomerRepository
OrderRepository

Masalahnya, jika isi ketiga repository tersebut hampir sama, akan ada banyak kode yang sebenarnya hanya berbeda pada tipe data yang digunakan.

Generic memungkinkan logika tersebut ditulis satu kali:

public class Repository<T>
{
    private readonly List<T> _items = new List<T>();

    public void Add(T item)
    {
        _items.Add(item);
    }

    public bool Remove(T item)
    {
        return _items.Remove(item);
    }

    public T? Find(Func<T, bool> predicate)
    {
        return _items.FirstOrDefault(predicate);
    }

    public IEnumerable<T> GetAll()
    {
        return _items;
    }
}

Sekilas, mungkin terlihat banyak T pada class tersebut. Sebenarnya semuanya mengacu pada tipe data yang sama.

Jika digunakan sebagai Repository<Product>, maka semua T di dalam repository tersebut mengacu pada Product.

Jika digunakan sebagai Repository<Customer>, semua T mengacu pada Customer.

Secara sederhana:

Repository<T>
      │
      ├── Repository<Product>
      │       └── T = Product
      │
      ├── Repository<Customer>
      │       └── T = Customer
      │
      └── Repository<Order>
              └── T = Order

List<T>

Perhatikan property _items:

private readonly List<T> _items = new List<T>();

Karena List juga merupakan Generic Class, T dapat digunakan sebagai tipe elemennya.

Jika repository dibuat sebagai:

Repository<Product> productRepo = new Repository<Product>();

maka _items pada repository tersebut menjadi sebuah List<Product>.

Begitu juga jika dibuat:

Repository<Customer> customerRepo = new Repository<Customer>();

maka _items menjadi List<Customer>.

Dengan begitu, repository tidak perlu mengetahui sejak awal apakah data yang akan dikelola berupa Product, Customer, atau tipe lainnya.

Method Add

Method Add menggunakan T sebagai parameter:

public void Add(T item)
{
    _items.Add(item);
}

Artinya, tipe parameter item selalu mengikuti tipe T.

Pada Repository<Product>:

var productRepo = new Repository<Product>();

productRepo.Add(new Product());

Add() menerima Product.

Sedangkan pada Repository<Customer>:

var customerRepo = new Repository<Customer>();

customerRepo.Add(new Customer());

Add() menerima Customer.

Jika tipe yang salah diberikan:

productRepo.Add(new Customer());

compiler akan menolaknya.

Informasi tipe yang diberikan ketika Repository<Product> dibuat tetap berlaku untuk penggunaan repository tersebut.

Method Find

Bagian berikutnya sedikit lebih menarik:

public T? Find(Func<T, bool> predicate)
{
    return _items.FirstOrDefault(predicate);
}

Method Find menerima Func<T, bool> sebagai parameter.

Func<T, bool> dapat dipahami secara sederhana sebagai sebuah fungsi yang menerima T dan menghasilkan bool.

Misalnya pada Repository<Product>:

productRepo.Find(p => p.Name == "Mouse");

p merupakan sebuah Product, sehingga property seperti Name dapat langsung digunakan.

Pada Repository<Customer>:

customerRepo.Find(c => c.Name == "Dewi");

c merupakan Customer.

Di sini Generic tidak hanya menentukan tipe data yang disimpan, tetapi juga membuat tipe tersebut mengalir ke bagian lain dari class.

T? pada Return Type

Method Find menggunakan:

T? Find(...)

Tanda ? menunjukkan bahwa hasil pencarian mungkin tidak memiliki nilai.

Misalnya, ketika tidak ada Product dengan nama "Mouse", method Find dapat menghasilkan null.

Karena itu, hasilnya dapat digunakan dengan null-conditional operator:

var found = productRepo.Find(p => p.Name == "Mouse");

Console.WriteLine(found?.Price);

?. memastikan property Price hanya diakses jika found tidak null.

Detail mengenai nullable reference types dan aturan T? pada Generic akan lebih mudah dipahami setelah konsep Generic dasarnya sudah dikuasai.

Entitas yang Digunakan

Agar contoh lebih mudah dibayangkan, misalkan aplikasi memiliki tiga entitas berikut:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
}

public class Order
{
    public int Id { get; set; }
    public int CustomerId { get; set; }
    public decimal Total { get; set; }
}

Tidak ada hubungan khusus antara ketiga class tersebut dengan Repository<T>.

Justru di situlah letak manfaat Generic pada contoh ini. Repository<T> tidak perlu mengetahui detail masing-masing class.

Menggunakan Repository<T>

Repository dapat digunakan dengan tipe yang berbeda:

var productRepo = new Repository<Product>();

productRepo.Add(new Product
{
    Id = 1,
    Name = "Keyboard",
    Price = 250000
});

productRepo.Add(new Product
{
    Id = 2,
    Name = "Mouse",
    Price = 120000
});

var customerRepo = new Repository<Customer>();

customerRepo.Add(new Customer
{
    Id = 1,
    Name = "Dewi"
});

Pencarian juga tetap mendapatkan manfaat dari informasi tipe tersebut:

var found = productRepo.Find(p => p.Name == "Mouse");

Console.WriteLine(found?.Price);
// Output: 120000

Karena productRepo adalah Repository<Product>, compiler mengetahui bahwa p merupakan Product.

Seluruh data di dalam repository juga memiliki tipe yang sama:

foreach (var product in productRepo.GetAll())
{
    Console.WriteLine($"{product.Name} - {product.Price}");
}

Output:

Keyboard - 250000
Mouse - 120000

Tidak diperlukan casting ketika mengambil data dari repository.

Satu Class, Banyak Tipe

Pada akhirnya, tiga repository berikut semuanya berasal dari satu class:

var productRepo = new Repository<Product>();
var customerRepo = new Repository<Customer>();
var orderRepo = new Repository<Order>();

Yang berbeda hanya tipe yang diberikan sebagai parameter.

Repository<Product>   → T = Product
Repository<Customer>  → T = Customer
Repository<Order>     → T = Order
Tidak perlu membuat implementasi baru hanya karena tipe datanya berbeda.

Misalnya, ketika aplikasi membutuhkan repository untuk Invoice, cukup gunakan:

var invoiceRepo = new Repository<Invoice>();

Selama operasi yang dibutuhkan memang sama, logika yang sudah ada dapat digunakan kembali.

Mengapa Ini Penting?

Contoh Repository<T> menunjukkan salah satu manfaat utama Generic Class: logika yang tidak bergantung pada tipe tertentu dapat dipisahkan dari tipe data yang digunakan.

Repository<T> tidak perlu mengetahui apakah T adalah Product, Customer, Order, atau Invoice.

Yang perlu diketahui hanyalah bahwa repository bekerja dengan sebuah tipe T.

Hal ini membuat satu implementasi dapat digunakan kembali untuk berbagai tipe data sekaligus tetap mempertahankan type safety.

Generic juga dapat membantu mengurangi duplikasi kode. Jika tiga repository memiliki implementasi yang hampir sama, cukup ada satu implementasi yang perlu diperbaiki dan diuji.

Namun, perlu diingat bahwa contoh Repository<T> di sini terutama digunakan untuk menjelaskan konsep Generic Class. Dalam aplikasi nyata, desain repository dapat membutuhkan pertimbangan lain seperti database access, query, transaction, unit of work, specification, dan kebutuhan arsitektur aplikasi.

Dengan memahami contoh sederhana ini, konsep Generic Class sudah mulai terlihat: class tidak harus mengetahui tipe data yang digunakan sejak awal. Tipe tersebut dapat diberikan ketika class digunakan, sementara compiler tetap menjaga aturan tipenya.

Setelah Generic Class, konsep yang sama dapat diterapkan pada level yang lebih kecil, yaitu Generic Method.

Bagian 6: Generic Method

Generic tidak selalu harus diterapkan pada seluruh class. Ada situasi ketika sebuah class hanya memiliki satu atau beberapa method yang perlu bekerja dengan berbagai tipe data. Jika seluruh class dibuat Generic hanya karena satu method, desainnya justru bisa menjadi lebih rumit dari yang diperlukan. Untuk kondisi seperti ini, Generic Method dapat digunakan. Dengan Generic Method, type parameter hanya berlaku pada method tersebut. Class yang menampungnya tetap dapat berupa class biasa.

Sintaks Dasar

Berikut contoh sederhana:

public T Max<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) > 0 ? a : b;
}

Ada satu bagian yang menjadi ciri khas Generic Method:

Max<T>

<T> diletakkan setelah nama method, bukan setelah nama class. Pada contoh tersebut, T digunakan sebagai tipe dari parameter a, parameter b, dan nilai yang dikembalikan oleh method. Method tersebut dapat digunakan untuk berbagai tipe data selama tipe tersebut memenuhi constraint yang diberikan.

Apa Fungsi where T : IComparable<T>?

Bagian berikut:

where T : IComparable<T>

disebut constraint.

Constraint memberikan batasan mengenai tipe apa saja yang boleh digunakan sebagai T. Dalam contoh Max<T>, method perlu membandingkan a dan b menggunakan:

a.CompareTo(b)

Karena itu, T harus memiliki CompareTo() yang sesuai. IComparable<T> digunakan untuk menyatakan kebutuhan tersebut kepada compiler.

Tanpa constraint:

public T Max<T>(T a, T b)
{
    return a.CompareTo(b) > 0 ? a : b;
}

compiler tidak dapat menjamin bahwa semua kemungkinan tipe T memiliki method CompareTo().

Pembahasan mengenai berbagai jenis constraint akan dibahas secara khusus pada bagian berikutnya. Untuk saat ini, cukup dipahami bahwa constraint digunakan untuk membatasi tipe yang dapat digunakan oleh Generic.

Menggunakan Max<T>

Method tersebut dapat digunakan dengan berbagai tipe:

int maxInt = Max(10, 25);

Console.WriteLine(maxInt);
// Output: 25

Method yang sama juga dapat digunakan untuk string:

string maxString = Max("apel", "jeruk");

Console.WriteLine(maxString);
// Output: jeruk

Tidak perlu membuat:

MaxInt()
MaxString()
MaxDouble()

Satu method Generic sudah cukup untuk menangani berbagai tipe yang memenuhi constraint.

Type Inference

Ada hal menarik pada pemanggilan berikut:

Max(10, 25);

Tidak terlihat <int> di sana. Namun, compiler tetap mengetahui bahwa T adalah int.

Compiler dapat melihat tipe argument yang diberikan:

10  → int
25  → int

Kemudian menyimpulkan:

T = int

Proses ini disebut type inference.

Karena itu, penulisan:

int result = Max(10, 25);

setara secara konsep dengan:

int result = Max<int>(10, 25);

Tipe Generic juga dapat ditulis secara eksplisit jika diperlukan:

int result = Max<int>(10, 25);

Dalam kebanyakan kasus, type inference membuat kode lebih ringkas tanpa kehilangan informasi tipe.

Contoh: Swap<T>

Contoh lain yang lebih sederhana adalah method Swap.

Method ini bertugas menukar nilai dari dua variabel:

public void Swap<T>(ref T a, ref T b)
{
    T temp = a;
    a = b;
    b = temp;
}

Tanpa Generic, mungkin diperlukan method yang berbeda untuk setiap tipe:

SwapInt()
SwapString()
SwapDouble()

Dengan Generic, cukup ada satu method.

Untuk int:

int x = 1;
int y = 2;

Swap(ref x, ref y);

Console.WriteLine($"{x}, {y}");
// Output: 2, 1

Method yang sama dapat digunakan untuk string:

string first = "kiri";
string second = "kanan";

Swap(ref first, ref second);

Console.WriteLine($"{first}, {second}");
// Output: kanan, kiri

Compiler menentukan T berdasarkan argument yang diberikan.

Pada pemanggilan pertama:

T = int

Sedangkan pada pemanggilan kedua:

T = string

Tidak ada kode yang perlu ditulis ulang.

Contoh: Print<T>

Generic Method juga dapat digunakan untuk membuat method yang menerima nilai dengan tipe apa pun:

public void Print<T>(T value)
{
    Console.WriteLine(
        $"Nilai: {value}, Tipe: {typeof(T).Name}"
    );
}

Method tersebut dapat dipanggil dengan berbagai tipe:

Print(100);
// Output: Nilai: 100, Tipe: Int32

Print("Halo");
// Output: Nilai: Halo, Tipe: String

Print(3.14);
// Output: Nilai: 3.14, Tipe: Double

Pada contoh ini terdapat:

typeof(T)

typeof(T) digunakan untuk mendapatkan informasi Type dari tipe yang digunakan sebagai T.

Meskipun method ditulis secara Generic dan tidak mengetahui tipe konkretnya ketika kode dibuat, informasi tipe tetap tersedia ketika Generic tersebut digunakan.

Hal ini juga menunjukkan bahwa Generic tidak berarti tipe datanya "hilang" atau menjadi object. Informasi tipe tetap dipertahankan.

Contoh: Compare<T>

Generic Method juga dapat digunakan untuk melakukan perbandingan:

public int Compare<T>(T a, T b)
    where T : IComparable<T>
{
    return a.CompareTo(b);
}

Contoh penggunaannya:

int result = Compare(5, 10);

Console.WriteLine(result);
// Output: -1

Karena 5 lebih kecil daripada 10, CompareTo() menghasilkan nilai negatif.

Method ini mirip dengan Max<T>, tetapi hasilnya bukan salah satu dari kedua nilai tersebut. Hasil perbandingan dikembalikan langsung sehingga kode yang memanggil method dapat menentukan sendiri bagaimana hasil tersebut akan digunakan.

Misalnya:

int result = Compare(5, 10);

if (result < 0)
{
    Console.WriteLine("Nilai pertama lebih kecil");
}
else if (result > 0)
{
    Console.WriteLine("Nilai pertama lebih besar");
}
else
{
    Console.WriteLine("Kedua nilai sama");
}

Generic Method vs Generic Class

Perbedaan antara Generic Class dan Generic Method sebenarnya cukup sederhana. Generic Class menjadikan tipe sebagai bagian dari class tersebut.

Contohnya:

Repository<Product> productRepository = new Repository<Product>();

Instance productRepository tersebut bekerja dengan Product. Jika ingin menggunakan Customer, dibuat instance lain:

Repository<Customer> customerRepository = new Repository<Customer>();

Sementara itu, Generic Method menentukan tipe ketika method dipanggil.

Contohnya:

public class Utility
{
    public T Max<T>(T a, T b)
        where T : IComparable<T>
    {
        return a.CompareTo(b) > 0 ? a : b;
    }
}

Utility sendiri bukan Generic Class.

Namun, method Max di dalamnya adalah Generic Method.

Karena itu, satu object Utility dapat digunakan untuk berbagai tipe:

var utility = new Utility();

int maxNumber = utility.Max(10, 20);

string maxText = utility.Max("apel", "jeruk");

Pada pemanggilan pertama:

T = int

Pada pemanggilan kedua:

T = string

Tipe T ditentukan secara independen pada setiap pemanggilan method.

Secara sederhana, perbedaannya dapat digambarkan seperti ini:

Generic Class
     │
     └── T ditentukan ketika instance dibuat
         Repository<Product>
         Repository<Customer>


Generic Method
     │
     └── T dapat ditentukan setiap kali method dipanggil
         Max(10, 20)          → T = int
         Max("apel", "jeruk") → T = string

Pemilihan antara Generic Class dan Generic Method bergantung pada di mana kebutuhan terhadap tipe Generic tersebut berada.

Jika seluruh object perlu terikat pada suatu tipe, Generic Class mungkin lebih sesuai.

Jika hanya satu operasi yang perlu bekerja dengan berbagai tipe, Generic Method biasanya sudah cukup.

Konsep ini banyak digunakan dalam library .NET. Berbagai method seperti operasi collection, utility, dan algoritma umum dapat dibuat Generic tanpa membuat seluruh class menjadi Generic.

Setelah memahami Generic Class dan Generic Method, bagian berikutnya akan membahas Generic Interface. Di sana, konsep Generic tidak lagi hanya digunakan untuk implementasi, tetapi juga untuk mendefinisikan kontrak yang dapat digunakan oleh berbagai tipe.

Bagian 7: Generic Interface

Selain class dan method, interface juga bisa dibuat generic. Generic Interface berguna ketika sebuah kontrak perlu berlaku untuk berbagai tipe data, tapi tetap ingin memastikan bahwa setiap implementasi konsisten secara struktur.

Mendefinisikan IRepository<T>

Melanjutkan contoh Repository<T> dari bagian sebelumnya, kontrak yang mendasarinya bisa diekstrak menjadi sebuah interface:

public interface IRepository<T>
{
    void Add(T item);
    bool Remove(T item);
    T? Find(Func<T, bool> predicate);
    IEnumerable<T> GetAll();
}

Interface ini mendefinisikan apa saja yang harus dimiliki oleh sebuah repository, tanpa menentukan bagaimana data sebenarnya disimpan. Detail penyimpanan diserahkan sepenuhnya kepada class yang mengimplementasikannya.

Implementasi: MemoryRepository<T>

public class MemoryRepository<T> : IRepository<T>
{
    private readonly List<T> _items = new List<T>();

    public void Add(T item)
    {
        _items.Add(item);
    }

    public bool Remove(T item)
    {
        return _items.Remove(item);
    }

    public T? Find(Func<T, bool> predicate)
    {
        return _items.FirstOrDefault(predicate);
    }

    public IEnumerable<T> GetAll()
    {
        return _items;
    }
}

MemoryRepository<T> menyimpan data di memori menggunakan List<T>, sesuai namanya. Karena mengimplementasikan IRepository<T>, class ini terikat kontrak untuk menyediakan keempat method tersebut, dengan tipe data yang konsisten di setiap methodnya.

Penggunaan Melalui Interface

IRepository<Product> productRepo = new MemoryRepository<Product>();
productRepo.Add(new Product { Id = 1, Name = "Monitor", Price = 1500000 });

var product = productRepo.Find(p => p.Id == 1);
Console.WriteLine(product?.Name); // Output: Monitor

Kode di atas mendeklarasikan variabel bertipe IRepository<Product>, bukan MemoryRepository<Product> secara langsung. Ini adalah praktik umum yang dikenal sebagai program to an interface, not an implementation: kode yang bergantung pada IRepository<T> tidak perlu tahu atau peduli apakah data disimpan di memori, database, atau file — selama kontraknya dipenuhi.

Keuntungan Generic Interface

Ada beberapa keuntungan nyata dari pendekatan ini:

Fleksibilitas implementasi. Di kemudian hari, DatabaseRepository<T> atau CachedRepository<T> bisa dibuat sebagai implementasi alternatif dari IRepository<T>, tanpa mengubah kode yang sudah bergantung pada interface tersebut.

public class DatabaseRepository<T> : IRepository<T>
{
    // implementasi berbeda, kontrak tetap sama
}

Kemudahan testing. Saat menulis unit test, implementasi asli seperti DatabaseRepository<T> bisa digantikan dengan implementasi tiruan (mock) yang juga mengimplementasikan IRepository<T>, tanpa menyentuh kode yang diuji.

Konsistensi struktur. Setiap class yang mengimplementasikan IRepository<T> dijamin memiliki method Add, Remove, Find, dan GetAll dengan signature yang sama, sehingga developer lain yang membaca kode langsung tahu apa yang bisa diharapkan dari sebuah repository, tanpa perlu membaca detail implementasinya satu per satu.

Loose coupling. Kode yang bergantung pada IRepository<T> menjadi tidak terikat pada detail implementasi tertentu, sehingga perubahan pada cara data disimpan tidak merambat ke seluruh bagian aplikasi yang menggunakan repository tersebut.

Kombinasi Generic dan interface seperti ini adalah dasar dari banyak pola desain di .NET, termasuk dependency injection, di mana implementasi konkret dari sebuah interface generic bisa didaftarkan dan diganti sesuai kebutuhan tanpa mengubah kode yang menggunakannya.

Bagian 8: Generic Struct

Generic tidak hanya berlaku untuk reference type seperti class dan interface. Value type seperti struct juga bisa dibuat generic, dan penerapannya cukup umum ditemui — salah satu contoh paling dikenal di .NET adalah KeyValuePair<TKey, TValue>, yang sebenarnya adalah struct generic.

Studi Kasus: Pair<TFirst, TSecond>

Struct generic sering digunakan untuk membungkus dua nilai atau lebih yang saling berkaitan, tanpa perlu membuat class terpisah untuk setiap kombinasi tipe data.

public struct Pair<TFirst, TSecond>
{
    public TFirst First { get; set; }
    public TSecond Second { get; set; }

    public Pair(TFirst first, TSecond second)
    {
        First = first;
        Second = second;
    }

    public override string ToString()
    {
        return $"({First}, {Second})";
    }
}

Pair<TFirst, TSecond> menerima dua type parameter sekaligus, yang tidak harus bertipe sama. Ini memungkinkan penggabungan dua nilai dengan tipe data berbeda dalam satu unit data yang ringkas.

Penggunaan Pair<TFirst, TSecond>

var coordinate = new Pair<int, int>(10, 20);
Console.WriteLine(coordinate); // Output: (10, 20)

var studentScore = new Pair<string, double>("Rani", 92.5);
Console.WriteLine(studentScore); // Output: (Rani, 92.5)

var idStatus = new Pair<int, bool>(101, true);
Console.WriteLine(idStatus); // Output: (101, True)

Ketiga variabel di atas menggunakan struct yang sama, hanya berbeda pada kombinasi tipe data yang diisikan ke TFirst dan TSecond.

Mengapa Struct, Bukan Class?

Perbedaan mendasar antara struct dan class terletak pada cara keduanya disimpan dan disalin. Class adalah reference type — variabel yang menampung instance class sebenarnya hanya menyimpan referensi ke lokasi data di heap. Struct adalah value type — variabel yang menampung instance struct langsung berisi datanya sendiri, biasanya dialokasikan di stack.

Untuk data kecil yang sering dibuat dan dibuang dalam jumlah besar, seperti koordinat, pasangan key-value, atau titik dalam ruang, struct cenderung lebih efisien karena tidak membebani garbage collector dengan alokasi heap yang berulang. Namun, karena struct disalin berdasarkan nilai (bukan referensi), setiap kali sebuah Pair<T1, T2> diteruskan ke method lain atau disalin ke variabel baru, seluruh isinya digandakan.

var original = new Pair<int, int>(1, 2);
var copy = original;
copy.First = 99;

Console.WriteLine(original.First); // Output: 1 (tidak berubah)
Console.WriteLine(copy.First);     // Output: 99

Perilaku ini berbeda dari class generic seperti Box<T> pada bagian sebelumnya, di mana menyalin variabel hanya menyalin referensinya, sehingga perubahan pada satu variabel ikut terlihat pada variabel lainnya.

Kapan Menggunakan Struct Generic

Struct generic paling cocok digunakan untuk data yang:

• berukuran kecil, biasanya hanya berisi beberapa field sederhana
• bersifat immutable atau jarang diubah setelah dibuat
• sering dibuat dalam jumlah besar dan berumur pendek, misalnya dalam perhitungan atau iterasi
• secara semantik memang lebih masuk akal diperlakukan sebagai "nilai" dibanding "objek", seperti koordinat atau rentang angka

Sebaliknya, jika data yang dibungkus cukup besar, sering diubah dan dibagikan antar bagian kode, atau butuh identitas referensi yang konsisten, Generic Class biasanya jadi pilihan yang lebih tepat dibanding Generic Struct.

Bagian selanjutnya akan membahas Multiple Generic Type — bagaimana sebuah class atau struct bisa menerima lebih dari satu type parameter sekaligus, seperti yang sudah terlihat sekilas pada Pair<TFirst, TSecond> di atas.

Bagian 9: Multiple Generic Type

Sejauh ini, sebagian besar contoh menggunakan satu type parameter (T). Namun, seperti yang sudah terlihat pada Pair<TFirst, TSecond> di bagian sebelumnya, sebuah class, struct, interface, atau method bisa menerima lebih dari satu type parameter sekaligus. Salah satu contoh paling umum ditemui di .NET adalah Dictionary<TKey, TValue>.

Dictionary<TKey, TValue>

Dictionary<int, string> users = new Dictionary<int, string>();
users.Add(1, "Andi");
users.Add(2, "Budi");

Console.WriteLine(users[1]); // Output: Andi

Dictionary<TKey, TValue> menggunakan dua type parameter: TKey untuk tipe data kunci, dan TValue untuk tipe data nilai yang terasosiasi dengannya. Kedua tipe ini tidak harus sama — pada contoh di atas, TKey adalah int dan TValue adalah string.

Studi Kasus: Result<TSuccess, TError>

Pola ini sering dipakai untuk merepresentasikan hasil operasi yang bisa berhasil atau gagal, tanpa mengandalkan exception untuk kasus kegagalan yang memang diperkirakan bisa terjadi.

public class Result<TSuccess, TError>
{
    public bool IsSuccess { get; }
    public TSuccess? Value { get; }
    public TError? Error { get; }

    private Result(bool isSuccess, TSuccess? value, TError? error)
    {
        IsSuccess = isSuccess;
        Value = value;
        Error = error;
    }

    public static Result<TSuccess, TError> Success(TSuccess value) =>
        new Result<TSuccess, TError>(true, value, default);

    public static Result<TSuccess, TError> Failure(TError error) =>
        new Result<TSuccess, TError>(false, default, error);
}

Result<int, string> Divide(int a, int b)
{
    if (b == 0)
        return Result<int, string>.Failure("Tidak bisa membagi dengan nol");

    return Result<int, string>.Success(a / b);
}

var result = Divide(10, 2);
if (result.IsSuccess)
    Console.WriteLine($"Hasil: {result.Value}"); // Output: Hasil: 5

var failedResult = Divide(10, 0);
if (!failedResult.IsSuccess)
    Console.WriteLine($"Error: {failedResult.Error}"); // Output: Error: Tidak bisa membagi dengan nol

Pola Result<TSuccess, TError> memungkinkan kegagalan operasi diperlakukan sebagai bagian normal dari alur program, bukan sebagai kondisi eksepsional yang harus ditangkap dengan try-catch. Pemanggil method secara eksplisit diarahkan untuk memeriksa IsSuccess sebelum mengakses Value, sehingga alur error-handling menjadi lebih eksplisit dan mudah diikuti.

Studi Kasus: Response<TData, TMetadata>

Pola serupa juga umum ditemukan pada respons API, di mana data utama perlu dipisahkan dari informasi tambahan seperti paginasi.

public class Response<TData, TMetadata>
{
    public TData Data { get; set; } = default!;
    public TMetadata Metadata { get; set; } = default!;
}

public class PaginationInfo
{
    public int Page { get; set; }
    public int TotalPages { get; set; }
}

var response = new Response<List<Product>, PaginationInfo>
{
    Data = new List<Product> { new Product { Id = 1, Name = "Headset", Price = 300000 } },
    Metadata = new PaginationInfo { Page = 1, TotalPages = 5 }
};

Console.WriteLine(response.Data[0].Name);        // Output: Headset
Console.WriteLine(response.Metadata.TotalPages);  // Output: 5

Pair<T1, T2>: Penamaan Type Parameter

Penamaan type parameter tidak harus selalu deskriptif seperti TKey dan TValue. Untuk kasus generik yang benar-benar tidak punya makna spesifik, penamaan sederhana seperti T1 dan T2 juga umum digunakan, terutama pada struct pembantu seperti Pair<T1, T2> yang sudah dibahas sebelumnya.

public struct Pair<T1, T2>
{
    public T1 Item1 { get; set; }
    public T2 Item2 { get; set; }
}

Meski begitu, praktik terbaik umumnya menyarankan penamaan yang deskriptif ketika maknanya jelas — misalnya TKey/TValue untuk pasangan kunci-nilai, atau TSuccess/TError untuk hasil operasi. Penamaan yang jelas membuat kode lebih mudah dipahami tanpa perlu membaca implementasinya secara detail. Pembahasan lebih lanjut mengenai konvensi penamaan akan dibahas pada bagian Best Practices.

Tidak Ada Batasan Jumlah Type Parameter

Meskipun dua type parameter adalah yang paling umum, C# tidak membatasi jumlahnya secara ketat. Class atau method bisa saja memiliki tiga, empat, atau lebih type parameter jika memang dibutuhkan. Namun, semakin banyak type parameter yang digunakan, semakin kompleks juga kode tersebut untuk dibaca dan dipahami. Umumnya, jika sebuah class atau method sudah membutuhkan lebih dari dua atau tiga type parameter, ini bisa jadi tanda bahwa desainnya perlu dipertimbangkan ulang — topik ini akan disinggung lebih lanjut pada bagian Kesalahan Umum.

Setelah memahami bagaimana Generic bekerja dengan satu atau lebih type parameter, bagian selanjutnya akan membahas salah satu aspek terpenting dari Generic: Constraints — cara membatasi tipe data apa saja yang boleh digunakan sebagai type parameter.

Bagian 10: Generic Constraints

Sejauh ini, type parameter seperti T bisa diisi dengan tipe data apa pun tanpa batasan. Pada sebagian besar kasus, ini baik-baik saja. Tapi ada situasi di mana sebuah Generic Class atau Generic Method perlu melakukan sesuatu yang spesifik terhadap T dan tidak semua tipe data punya kemampuan itu.

Di sinilah constraints berperan. Constraint adalah cara membatasi tipe data apa saja yang boleh digunakan sebagai type parameter, sehingga compiler bisa menjamin bahwa T akan selalu punya kemampuan yang dibutuhkan.

Tanpa constraint, kode berikut tidak akan bisa dikompilasi:

public T CreateInstance<T>()
{
    return new T(); // Error: 'T' tidak dijamin punya constructor kosong
}

Compiler tidak tahu apakah setiap kemungkinan tipe T punya constructor tanpa parameter. Constraint where T : new() menyelesaikan masalah ini. Setiap constraint akan dibahas satu per satu berikut ini.

where T : class

Constraint ini membatasi T hanya boleh diisi dengan reference type: class, interface, delegate, atau array. Value type seperti int atau struct tidak diperbolehkan.

public class Cache<T> where T : class
{
    private T? _cached;

    public void Set(T value) => _cached = value;
    public T? Get() => _cached;
}

var cache = new Cache<Product>(); // boleh, Product adalah class
// var invalidCache = new Cache<int>(); // Error: int adalah value type

Constraint ini cocok digunakan ketika logika di dalam class memang mengandalkan sifat reference type, misalnya perbandingan referensi (ReferenceEquals) atau kemungkinan nilai null.

where T : struct

Kebalikan dari class, constraint ini membatasi T hanya boleh diisi dengan value type — termasuk int, double, bool, enum, dan struct custom.

public struct Wrapper<T> where T : struct
{
    public T Value { get; set; }
}

var wrapper = new Wrapper<int> { Value = 10 }; // boleh
// var invalidWrapper = new Wrapper<string> { Value = "teks" }; // Error: string adalah reference type

Constraint struct sering dikaitkan dengan Nullable<T>, yang sebenarnya didefinisikan dengan constraint ini di balik layar:

public struct Nullable<T> where T : struct
{
    // ...
}

Inilah sebabnya int? (yang merupakan singkatan dari Nullable<int>) valid, tapi string? bukan berasal dari Nullable<T> — karena string adalah reference type dan sudah secara alami bisa bernilai null tanpa perlu dibungkus Nullable<T>.

where T : unmanaged

Constraint ini lebih ketat dari struct, T harus berupa value type yang tidak mengandung reference type apa pun di dalamnya, baik secara langsung maupun tidak langsung (misalnya int, float, bool, atau struct yang seluruh fieldnya juga unmanaged).

public unsafe void PrintBytes<T>(T value) where T : unmanaged
{
    int size = sizeof(T);
    Console.WriteLine($"Ukuran {typeof(T).Name}: {size} byte");
}

PrintBytes(100);     // Output: Ukuran Int32: 4 byte
PrintBytes(3.14);    // Output: Ukuran Double: 8 byte

Constraint ini umumnya dibutuhkan pada operasi tingkat rendah yang berkaitan dengan memori, seperti interop dengan kode native atau operasi menggunakan pointer (sizeof(T) pada contoh di atas hanya valid jika T dijamin unmanaged).

where T : notnull

Constraint ini memastikan T tidak boleh berupa tipe nullable, baik reference type yang bisa null (string?) maupun Nullable<T> (int?).

public class NonNullBox<T> where T : notnull
{
    public T Value { get; set; }

    public NonNullBox(T value)
    {
        Value = value;
    }
}

Perbedaannya dengan where T : class cukup penting untuk dipahami: class membatasi T harus reference type (boleh null secara alami), sedangkan notnull membatasi T tidak boleh bernilai null, tapi tetap membolehkan baik reference type maupun value type selama nilainya dijamin tidak null. Constraint ini banyak dipakai bersamaan dengan nullable reference types, fitur yang membantu compiler memperingatkan potensi NullReferenceException sejak compile-time.

where T : new()

Constraint ini memastikan T punya constructor publik tanpa parameter, sehingga instance baru bisa dibuat langsung dari dalam Generic Class atau Generic Method menggunakan new T().

public T CreateInstance<T>() where T : new()
{
    return new T();
}

public class Product
{
    public string Name { get; set; } = "Produk Baru";
}

var product = CreateInstance<Product>();
Console.WriteLine(product.Name); // Output: Produk Baru

Tanpa constraint new(), baris return new T(); tidak akan lolos compile, karena compiler tidak bisa memastikan setiap kemungkinan tipe T memang punya constructor kosong yang bisa dipanggil.

where T : BaseClass

Constraint ini membatasi T harus berupa class tertentu atau turunannya (subclass).

public abstract class Animal
{
    public abstract string MakeSound();
}

public class Dog : Animal
{
    public override string MakeSound() => "Guk!";
}

public class AnimalHandler<T> where T : Animal
{
    public void Handle(T animal)
    {
        Console.WriteLine(animal.MakeSound());
    }
}

var handler = new AnimalHandler<Dog>();
handler.Handle(new Dog()); // Output: Guk!

Dengan constraint where T : Animal, method Handle bisa memanggil MakeSound() dengan aman, karena compiler menjamin bahwa T pasti merupakan Animal atau turunannya, sehingga method tersebut pasti tersedia.

where T : Interface

Mirip dengan constraint berbasis class, tapi membatasi T harus mengimplementasikan interface tertentu.

public interface IEntity
{
    int Id { get; }
}

public class EntityValidator<T> where T : IEntity
{
    public bool IsValid(T entity)
    {
        return entity.Id > 0;
    }
}

public class Order : IEntity
{
    public int Id { get; set; }
}

var validator = new EntityValidator<Order>();
Console.WriteLine(validator.IsValid(new Order { Id = 5 })); // Output: True
Console.WriteLine(validator.IsValid(new Order { Id = 0 })); // Output: False

Constraint berbasis interface ini sangat umum ditemui pada pola seperti Generic Repository, di mana entitas yang dikelola perlu dijamin memiliki properti tertentu, misalnya Id, tanpa memaksa entitas tersebut mewarisi class dasar tertentu.

Multiple Constraints

Lebih dari satu constraint bisa digabungkan sekaligus pada satu type parameter, dipisahkan dengan koma.

public class EntityFactory<T> where T : class, IEntity, new()
{
    public T CreateNew()
    {
        return new T();
    }
}

Ada urutan penulisan yang perlu diikuti ketika constraint digabungkan:

1. Constraint tipe utama lebih dulu: class atau struct, jika ada.
2. Diikuti oleh satu atau lebih constraint interface atau base class.
3. Constraint new() selalu ditulis paling akhir, jika digunakan.

where T : class, IEntity, IComparable<T>, new()

Perlu dicatat, class dan struct tidak bisa digabungkan sekaligus pada type parameter yang sama, karena keduanya saling eksklusif, T tidak mungkin sekaligus reference type dan value type.

Ringkasan Constraints

Constraint pada dasarnya adalah cara memberi tahu compiler "percayalah, T akan selalu punya kemampuan ini", sehingga Generic Class atau Generic Method bisa memanfaatkan kemampuan tersebut dengan aman, tanpa perlu casting atau pengecekan tipe secara manual saat runtime.

Bagian 11: Generic Delegates

Delegate adalah sebuah tipe yang dapat menyimpan referensi ke method. Dengan delegate, sebuah method dapat diperlakukan seperti sebuah nilai: disimpan dalam variabel, diberikan sebagai parameter ke method lain, atau dikembalikan sebagai hasil dari sebuah method.

Pembahasan mengenai konsep dasar Delegate, cara membuatnya, serta penggunaannya di C# sudah dibahas lebih dahulu dalam artikel Memahami C# Delegate: Konsep, Cara Kerja, dan Contoh Penggunaan. Bagian ini tidak mengulang seluruh konsep tersebut, tetapi berfokus pada bagaimana Generic dapat digunakan pada Delegate.

Sama seperti class, struct, dan interface, delegate juga dapat dibuat Generic. Dengan Generic Delegate, satu definisi delegate dapat digunakan untuk berbagai tipe data tanpa harus membuat delegate baru untuk setiap variasi tipe.

Mendefinisikan Generic Delegate

Sebagai contoh, buat sebuah delegate yang menerima string dan mengembalikan tipe T:

public delegate T Converter<T>(string value);

Pada deklarasi tersebut:

Converter<T>
       │
       └── tipe return ditentukan kemudian

T merupakan type parameter yang belum ditentukan.

Ketika delegate digunakan sebagai:

Converter<int>

maka T menjadi int.

Sedangkan:

Converter<double>

berarti T menjadi double.

Contohnya:

Converter<int> toInt =
    value => int.Parse(value);

Converter<double> toDouble =
    value => double.Parse(value);

int number = toInt("100");
double price = toDouble("99.5");

Console.WriteLine(number);
// Output: 100

Console.WriteLine(price);
// Output: 99.5