Generics C#: Class Generik, Method Generik dan Constraint

Generics membuatmu bisa menulis sebuah tipe atau method sekali lalu memakainya dengan banyak tipe, tanpa kehilangan keamanan tipe. Alih-alih List berisi object yang butuh cast dan menerima apa saja, kamu mendapat List<int> dan List<Order>, yang masing-masing diperiksa oleh compiler. Tipe pengganti di dalam kurung sudut, yang menurut kebiasaan bernama T, adalah parameter tipe; tipe yang diberikan pemanggil adalah argumen tipe.

Kenapa generics: masalah yang diselesaikannya

Sebelum ada generics (C# 1), koleksi menyimpan object. Kodenya bisa di-compile, tapi kesalahan baru ketahuan saat program berjalan, dan setiap int di-boxing saat dimasukkan:

var prices = new System.Collections.ArrayList();
prices.Add(9.99m);
prices.Add("12.50");                  // compiles: anything is an object
decimal total = 0;
foreach (object p in prices)
    total += (decimal)p;              // InvalidCastException on the string

Dengan List<decimal>, Add yang kedua menjadi error saat compile, loop-nya tidak butuh cast, dan nilai decimal disimpan sebagai decimal.

Class generik

Deklarasikan parameter tipe setelah nama class, lalu pakai seperti tipe lainnya di dalam class:

using System;
using System.Collections.Generic;

class Page<T>
{
    public IReadOnlyList<T> Items { get; }
    public int Number { get; }
    public int TotalPages { get; }

    public Page(IReadOnlyList<T> items, int number, int totalPages)
    {
        Items = items;
        Number = number;
        TotalPages = totalPages;
    }

    public bool HasNext => Number < TotalPages;

    public static Page<T> From(List<T> all, int number, int size)
    {
        int start = (number - 1) * size;
        int count = Math.Max(0, Math.Min(size, all.Count - start));
        int total = (all.Count + size - 1) / size;
        return new Page<T>(all.GetRange(start, count), number, total);
    }
}

class Program
{
    static void Main()
    {
        var names = new List<string> { "Ana", "Ben", "Chen", "Dara", "Eli" };
        Page<string> second = Page<string>.From(names, 2, 2);
        Console.WriteLine($"Page {second.Number}/{second.TotalPages}: {string.Join(", ", second.Items)}, more: {second.HasNext}");

        var scores = new List<int> { 90, 72, 85 };
        var first = Page<int>.From(scores, 1, 5);
        Console.WriteLine($"Page {first.Number}/{first.TotalPages}: {string.Join(", ", first.Items)}, more: {first.HasNext}");
    }
}

Output:

Page 2/3: Chen, Dara, more: True
Page 1/1: 90, 72, 85, more: False

Page<string> dan Page<int> adalah dua tipe berbeda yang dihasilkan dari satu definisi. Sebuah class bisa menerima beberapa parameter tipe (Dictionary<TKey, TValue>); beri nama T kalau hanya ada satu dan TSomething kalau ada beberapa.

Method generik dan inferensi tipe

Sebuah method bisa punya parameter tipenya sendiri, entah class-nya generik atau tidak. Pemanggil biasanya tidak menulis argumen tipe, karena compiler menyimpulkannya dari argumen:

using System;
using System.Collections.Generic;

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

    static List<T> Repeat<T>(T value, int times)
    {
        var list = new List<T>(times);
        for (int i = 0; i < times; i++) list.Add(value);
        return list;
    }

    static TOut[] Map<TIn, TOut>(TIn[] items, Func<TIn, TOut> convert)
    {
        var result = new TOut[items.Length];
        for (int i = 0; i < items.Length; i++) result[i] = convert(items[i]);
        return result;
    }

    static void Main()
    {
        int x = 1, y = 2;
        Swap(ref x, ref y);                  // T inferred as int
        Console.WriteLine($"{x} {y}");

        string first = "front", second = "back";
        Swap<string>(ref first, ref second); // explicit type argument
        Console.WriteLine($"{first} {second}");

        Console.WriteLine(string.Join(" ", Repeat("ho", 3)));

        decimal[] prices = { 4.5m, 12m, 0.99m };
        string[] labels = Map(prices, p => $"{p:F2} EUR");   // TIn and TOut inferred
        Console.WriteLine(string.Join(", ", labels));
    }
}

Output:

2 1
back front
ho ho ho
4.50 EUR, 12.00 EUR, 0.99 EUR

Inferensi hanya bekerja dari argumen, tidak pernah dari tipe kembalian. Repeat(0, 3) tidak butuh anotasi, tapi method seperti T Create<T>() tidak punya apa pun untuk dijadikan dasar inferensi, jadi pemanggil harus menulis Create<Customer>(). Sebagian besar LINQ adalah method generik yang mengandalkan inferensi ini: prices.Where(p => p > 1) adalah Where<decimal> tanpa perlu kamu tulis.

Constraint: tipe apa yang boleh menjadi T

Di dalam method generik, compiler hanya mengizinkan hal yang bisa berjalan untuk setiap kemungkinan T. Tanpa constraint, itu tidak jauh lebih banyak dari yang didukung object. Untuk memanggil CompareTo, membuat instance, atau membaca sebuah property, beri tahu compiler harus berupa apa T itu, dengan where:

using System;
using System.Collections.Generic;

abstract class Entity
{
    public int Id { get; set; }
}

class Customer : Entity
{
    public string Name { get; set; }
}

class Program
{
    // T must be comparable to itself, so CompareTo is available.
    static T Largest<T>(IEnumerable<T> items) where T : IComparable<T>
    {
        bool any = false;
        T best = default(T);
        foreach (T item in items)
        {
            if (!any || item.CompareTo(best) > 0) best = item;
            any = true;
        }
        if (!any) throw new InvalidOperationException("Sequence is empty");
        return best;
    }

    // T must derive from Entity (so .Id exists) and have a parameterless constructor.
    static T CreateWithId<T>(int id) where T : Entity, new()
    {
        var entity = new T();
        entity.Id = id;
        return entity;
    }

    static void Main()
    {
        Console.WriteLine(Largest(new[] { 3, 17, 8 }));
        Console.WriteLine(Largest(new List<string> { "pear", "apple", "plum" }));
        Console.WriteLine(Largest(new[] { 19.99m, 4.50m }));

        Customer c = CreateWithId<Customer>(42);
        c.Name = "Zoe";
        Console.WriteLine($"{c.Id} {c.Name}");
    }
}

Output:

17
plum
19.99
42 Zoe

Constraint yang akan kamu pakai:

Beberapa constraint pada satu parameter dipisahkan dengan koma; beberapa parameter masing-masing mendapat klausa where sendiri: class Cache<TKey, TValue> where TKey : notnull where TValue : class.

Constraint yang terlewat muncul sebagai error saat compile di tempat kamu memakai member tersebut, misalnya CS1061 ('T' does not contain a definition for 'CompareTo') atau CS0304 saat memanggil new T() tanpa new().

default(T)

Kode generik kadang butuh "nilai kosong" dari tipe yang tidak diketahuinya. default(T) memberikan 0 untuk angka, false untuk bool, null untuk reference type dan nullable type, dan struct berisi nol untuk lainnya:

using System;
using System.Collections.Generic;

class Program
{
    static T FindOrDefault<T>(List<T> items, Predicate<T> match)
    {
        foreach (T item in items)
            if (match(item)) return item;
        return default(T);
    }

    static void Main()
    {
        var ages = new List<int> { 12, 25, 31 };
        var cities = new List<string> { "Oslo", "Porto" };

        Console.WriteLine(FindOrDefault(ages, a => a > 30));
        Console.WriteLine(FindOrDefault(ages, a => a > 90));
        Console.WriteLine(FindOrDefault(cities, c => c.StartsWith("P")));
        Console.WriteLine(FindOrDefault(cities, c => c.StartsWith("Z")) == null);
        Console.WriteLine(default(DateTime).ToString("yyyy-MM-dd"));
    }
}

Output:

31
0
Porto
True
0001-01-01

Baris kedua menunjukkan kelemahan pola ini: untuk value type, "tidak ditemukan" dan "menemukan 0" terlihat sama. Itulah sebabnya method di framework memakai bentuk TryGet (bool TryGetValue(TKey key, out TValue value)). Sejak C# 7.1 kamu bisa menulis return default; yang lebih singkat saat tipenya sudah jelas dari konteks.

Member static berlaku per tipe yang dibentuk

Setiap tipe yang dibentuk (Counter<int>, Counter<string>) mendapat salinan field static class itu sendiri:

using System;

class Counter<T>
{
    public static int Created;
    public Counter() { Created++; }
}

class Program
{
    static void Main()
    {
        new Counter<int>();
        new Counter<int>();
        new Counter<string>();

        Console.WriteLine(Counter<int>.Created);
        Console.WriteLine(Counter<string>.Created);
        Console.WriteLine(typeof(Counter<int>) == typeof(Counter<string>));
    }
}

Output:

2
1
False

Hal ini kadang berguna (cache per tipe seperti TypeInfo<T>.Name yang dihitung sekali untuk setiap T) dan kadang mengejutkan saat kamu mengira ada satu penghitung bersama. Taruh state bersama di class yang tidak generik.

Koleksi generik

Koleksi generik mencukupi sebagian besar kebutuhan: List<T>, Dictionary<TKey, TValue>, HashSet<T>, Queue<T>, Stack<T>, beserta interface yang mereka miliki bersama, IEnumerable<T>, ICollection<T>, IList<T>, IReadOnlyList<T>. Terima interface paling sempit yang dibutuhkan sebuah method (IEnumerable<T> kalau method itu hanya melakukan perulangan), dan kembalikan tipe konkret atau tipe read-only.

Kovarians dan kontravarians

Dog adalah Animal, tapi List<Dog> bukan List<Animal>:

List<Dog> dogs = new List<Dog>();
List<Animal> animals = dogs;
// error CS0029: Cannot implicitly convert type 'List<Dog>' to 'List<Animal>'

Seandainya itu diperbolehkan, animals.Add(new Cat()) akan memasukkan kucing ke list anjing. Interface yang hanya menghasilkan nilai aman dipakai, dan interface seperti itu dideklarasikan kovarian dengan out:

IEnumerable<Animal> readOnly = dogs;          // fine: IEnumerable<out T>
IReadOnlyList<Animal> alsoFine = dogs;        // fine: IReadOnlyList<out T>

Kebalikannya, kontravarians, yang ditandai dengan in, berlaku untuk interface dan delegate yang hanya memakai nilai: Action<Animal> bisa dipakai di tempat yang mengharapkan Action<Dog>, karena sesuatu yang bisa menangani hewan apa pun pasti bisa menangani seekor anjing. IComparer<in T> bersifat kontravarian, dan Func<in T, out TResult> memakai kedua penanda itu. Varians hanya berlaku untuk interface dan delegate, dan hanya untuk argumen berupa reference type: IEnumerable<int> tidak bisa dikonversi menjadi IEnumerable<object>.

Kesalahan yang sering terjadi

• Memakai object di tempat yang seharusnya memakai parameter tipe. Cara ini membuang pemeriksaan saat compile dan melakukan boxing pada value type.
• Membandingkan dua nilai T dengan ==. Tanpa constraint class, kodenya tidak bisa di-compile (CS0019), dan dengan constraint itu yang dibandingkan adalah referensinya. Pakai EqualityComparer<T>.Default.Equals(a, b), yang bekerja untuk setiap T dan menghormati Equals milik tipe itu sendiri.
• Mengembalikan default(T) sebagai "tidak ditemukan". Hasilnya ambigu untuk value type. Pakai bool TryX(..., out T value).
• Terlalu banyak constraint. Setiap constraint mempersempit siapa yang bisa memakai method tersebut. Batasi hanya apa yang benar-benar dibutuhkan badan method.
• Mengira List<Derived> bisa dikonversi menjadi List<Base>. Terima IEnumerable<Base> atau IReadOnlyList<Base> sebagai gantinya.