Generics trong C#: lớp generic, phương thức và ràng buộc

Generics cho phép bạn viết một kiểu hoặc phương thức một lần rồi dùng với nhiều kiểu khác nhau mà không mất an toàn kiểu. Thay vì một List chứa object cần ép kiểu và nhận mọi thứ, bạn có List<int> và List<Order>, mỗi cái đều được trình biên dịch kiểm tra. Phần giữ chỗ trong dấu ngoặc nhọn, theo quy ước là T, là tham số kiểu (type parameter); kiểu mà nơi gọi cung cấp là đối số kiểu (type argument).

Vì sao cần generics: vấn đề chúng giải quyết

Trước khi có generics (C# 1), các collection lưu object. Code vẫn biên dịch được, nhưng lỗi chỉ lộ ra lúc chạy, và mỗi int đều bị boxing khi đưa vào:

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

Với List<decimal>, lệnh Add thứ hai là lỗi biên dịch, vòng lặp không cần ép kiểu, và các số decimal được lưu đúng dạng decimal.

Lớp generic

Khai báo tham số kiểu sau tên lớp, rồi dùng chúng như mọi kiểu khác bên trong lớp:

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}");
    }
}

Đầu ra:

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

Page<string> và Page<int> là hai kiểu khác nhau được tạo ra từ cùng một định nghĩa. Một lớp có thể nhận nhiều tham số kiểu (Dictionary<TKey, TValue>); đặt tên là T khi chỉ có một và TSomething khi có nhiều.

Phương thức generic và suy luận kiểu

Một phương thức có thể có tham số kiểu riêng, dù lớp chứa nó có generic hay không. Nơi gọi thường bỏ qua đối số kiểu, vì trình biên dịch suy ra từ các đối số:

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));
    }
}

Đầu ra:

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

Suy luận kiểu chỉ dựa vào đối số, không bao giờ dựa vào kiểu trả về. Repeat(0, 3) không cần chú thích kiểu, nhưng một phương thức như T Create<T>() không có gì để suy luận, nên nơi gọi phải viết Create<Customer>(). Phần lớn LINQ là các phương thức generic dựa vào cơ chế suy luận này: prices.Where(p => p > 1) chính là Where<decimal> mà bạn không cần viết ra.

Ràng buộc: T được phép là gì

Bên trong một phương thức generic, trình biên dịch chỉ cho bạn làm những gì hợp lệ với mọi T có thể có. Khi không có ràng buộc, điều đó chẳng hơn mấy so với những gì object hỗ trợ. Để gọi CompareTo, tạo instance hoặc đọc một thuộc tính, hãy cho trình biên dịch biết T phải là gì bằng 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}");
    }
}

Đầu ra:

17
plum
19.99
42 Zoe

Các ràng buộc bạn sẽ dùng:

Nhiều ràng buộc trên một tham số được ngăn cách bằng dấu phẩy; nhiều tham số thì mỗi tham số có mệnh đề where riêng: class Cache<TKey, TValue> where TKey : notnull where TValue : class.

Thiếu ràng buộc sẽ hiện thành lỗi biên dịch ngay chỗ bạn dùng thành viên đó, ví dụ CS1061 ('T' does not contain a definition for 'CompareTo') hoặc CS0304 khi gọi new T() mà không có new().

default(T)

Code generic đôi khi cần "giá trị rỗng" của một kiểu mà nó không biết. default(T) cho 0 với số, false với bool, null với kiểu tham chiếu và kiểu nullable, và một struct toàn giá trị 0 trong các trường hợp còn lại:

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"));
    }
}

Đầu ra:

31
0
Porto
True
0001-01-01

Dòng thứ hai cho thấy điểm yếu của cách làm này: với kiểu giá trị, "không tìm thấy" và "tìm thấy số 0" trông giống hệt nhau. Đó là lý do các phương thức của framework dùng dạng TryGet (bool TryGetValue(TKey key, out TValue value)). Từ C# 7.1, bạn có thể viết ngắn gọn return default; khi kiểu đã rõ từ ngữ cảnh.

Thành viên static riêng cho từng kiểu đã dựng

Mỗi kiểu đã dựng (Counter<int>, Counter<string>) có bản sao riêng của các trường static trong lớp:

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>));
    }
}

Đầu ra:

2
1
False

Điều này đôi khi hữu ích (một bộ nhớ đệm theo kiểu, chẳng hạn TypeInfo<T>.Name được tính một lần cho mỗi T) và đôi khi gây bất ngờ khi bạn tưởng chỉ có một bộ đếm dùng chung. Hãy đặt trạng thái dùng chung trong một lớp không generic.

Collection generic

Các collection generic đáp ứng hầu hết nhu cầu: List<T>, Dictionary<TKey, TValue>, HashSet<T>, Queue<T>, Stack<T>, cùng các interface chúng dùng chung là IEnumerable<T>, ICollection<T>, IList<T>, IReadOnlyList<T>. Hãy nhận interface hẹp nhất mà phương thức cần (IEnumerable<T> nếu nó chỉ lặp), và trả về một kiểu cụ thể hoặc kiểu chỉ đọc.

Hiệp biến và nghịch biến

Một Dog là một Animal, nhưng một List<Dog> không phải là List<Animal>:

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

Nếu điều đó được phép, animals.Add(new Cat()) sẽ cho một con mèo vào danh sách chó. Các interface chỉ tạo ra giá trị thì an toàn, và chúng được khai báo là hiệp biến (covariant) bằng out:

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

Mặt đối xứng, nghịch biến (contravariance), đánh dấu bằng in, áp dụng cho interface và delegate chỉ tiêu thụ giá trị: một Action<Animal> có thể dùng ở chỗ cần Action<Dog>, vì thứ gì xử lý được mọi con vật thì cũng xử lý được một con chó. IComparer<in T> có tính nghịch biến, và Func<in T, out TResult> dùng cả hai dấu hiệu. Tính biến thiên (variance) chỉ áp dụng cho interface và delegate, và chỉ với đối số là kiểu tham chiếu: IEnumerable<int> không chuyển được sang IEnumerable<object>.

Lỗi thường gặp

• Dùng object ở chỗ đáng lẽ là tham số kiểu. Cách này bỏ mất kiểm tra lúc biên dịch và gây boxing với kiểu giá trị.
• So sánh hai giá trị T bằng ==. Không có ràng buộc class thì code không biên dịch (CS0019), còn có ràng buộc thì nó so sánh tham chiếu. Hãy dùng EqualityComparer<T>.Default.Equals(a, b), cách này đúng với mọi T và tôn trọng Equals riêng của kiểu đó.
• Trả về default(T) để báo "không tìm thấy". Với kiểu giá trị, kết quả này mơ hồ. Hãy dùng bool TryX(..., out T value).
• Quá nhiều ràng buộc. Mỗi ràng buộc thu hẹp số người dùng được phương thức. Chỉ ràng buộc những gì phần thân thực sự cần.
• Mong List<Derived> chuyển được sang List<Base>. Hãy nhận IEnumerable<Base> hoặc IReadOnlyList<Base> thay vào đó.