Generics ב-C#: מחלקות גנריות, מתודות ואילוצים

Generics מאפשרים לכתוב טיפוס או מתודה פעם אחת ולהשתמש בהם עם טיפוסים רבים, בלי לוותר על בטיחות טיפוסים. במקום List של object שצריך המרות ומקבל כל דבר, מקבלים List<int> ו-List<Order>, שכל אחד מהם נבדק על ידי הקומפיילר. ממלא המקום שבסוגריים המשולשים, לפי המוסכמה T, הוא פרמטר טיפוס; הטיפוס שמי שקורא מספק הוא ארגומנט הטיפוס.

למה generics: הבעיה שהם פותרים

לפני generics (C# 1), אוספים שמרו object. זה התקמפל, אבל טעויות התגלו רק בזמן ריצה, וכל int עבר boxing בדרך פנימה:

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

עם List<decimal>, ה-Add השני הוא שגיאת קומפילציה, הלולאה לא צריכה המרה, וה-decimals נשמרים כ-decimals.

מחלקות גנריות

הצהירו על פרמטרי טיפוס אחרי שם המחלקה, ואז השתמשו בהם כמו בכל טיפוס אחר בתוך המחלקה:

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

פלט:

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

Page<string> ו-Page<int> הם שני טיפוסים שונים שנוצרו מהגדרה אחת. מחלקה יכולה לקבל כמה פרמטרי טיפוס (Dictionary<TKey, TValue>); קראו להם T כשיש אחד ו-TSomething כשיש כמה.

מתודות גנריות והסקת טיפוסים

למתודה יכולים להיות פרמטרי טיפוס משלה, בין אם המחלקה שלה גנרית ובין אם לא. מי שקורא בדרך כלל משמיט את ארגומנט הטיפוס, כי הקומפיילר מסיק אותו מהארגומנטים:

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

פלט:

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

ההסקה עובדת רק מהארגומנטים, אף פעם לא מטיפוס ההחזרה. Repeat(0, 3) לא צריך שום ציון, אבל למתודה כמו T Create<T>() אין ממה להסיק, ולכן מי שקורא חייב לכתוב Create<Customer>(). רוב LINQ הוא מתודות גנריות שנשענות על ההסקה הזו: prices.Where(p => p > 1) הוא Where<decimal> בלי שכתבתם את זה.

אילוצים: מה T רשאי להיות

בתוך מתודה גנרית, הקומפיילר מרשה לעשות רק מה שעובד עבור כל T אפשרי. בלי אילוץ, זה בקושי יותר ממה ש-object תומך בו. כדי לקרוא ל-CompareTo, ליצור מופע או לקרוא מאפיין, אמרו לקומפיילר מה T חייב להיות, עם 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}");
    }
}

פלט:

17
plum
19.99
42 Zoe

האילוצים שתשתמשו בהם:

כמה אילוצים על פרמטר אחד מופרדים בפסיקים; לכל אחד מכמה פרמטרים יש פסוקית where משלו: class Cache<TKey, TValue> where TKey : notnull where TValue : class.

אילוץ חסר מופיע כשגיאת קומפילציה במקום שבו משתמשים באיבר, למשל CS1061 ('T' does not contain a definition for 'CompareTo') או CS0304 כשקוראים ל-new T() בלי new().

default(T)

קוד גנרי צריך לפעמים את "הערך הריק" של טיפוס שהוא לא מכיר. default(T) נותן 0 למספרים, false ל-bool, null לטיפוסי הפניה ולטיפוסים nullable, ו-struct מאופס בכל מקרה אחר:

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

פלט:

31
0
Porto
True
0001-01-01

השורה השנייה מראה את החולשה של התבנית הזו: בטיפוסי ערך, "לא נמצא" ו"נמצא 0" נראים אותו דבר. זו הסיבה שמתודות של ה-framework משתמשות במקום זאת בצורת TryGet (bool TryGetValue(TKey key, out TValue value)). מאז C# 7.1 אפשר לכתוב את הצורה הקצרה return default; כשהטיפוס ברור מההקשר.

איברים סטטיים הם לכל טיפוס בנוי

כל טיפוס בנוי (Counter<int>, Counter<string>) מקבל עותק משלו של השדות הסטטיים של המחלקה:

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

פלט:

2
1
False

זה שימושי לפעמים (cache לכל טיפוס, כמו TypeInfo<T>.Name שמחושב פעם אחת לכל T) ומפתיע לפעמים, כשציפיתם למונה משותף אחד. שימו מצב משותף במחלקה לא גנרית.

אוספים גנריים

האוספים הגנריים מכסים את רוב הצרכים: List<T>, Dictionary<TKey, TValue>, HashSet<T>, Queue<T>, Stack<T>, והממשקים המשותפים להם, IEnumerable<T>, ICollection<T>, IList<T>, IReadOnlyList<T>. קבלו את הממשק הצר ביותר שהמתודה צריכה (IEnumerable<T> אם היא רק עוברת בלולאה), והחזירו טיפוס קונקרטי או טיפוס לקריאה בלבד.

Covariance ו-contravariance

Dog הוא Animal, אבל List<Dog> הוא לא List<Animal>:

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

אם זה היה מותר, animals.Add(new Cat()) היה מכניס חתול לרשימת הכלבים. ממשקים שרק מפיקים ערכים הם בטוחים, ומוצהרים כ-covariant עם out:

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

תמונת המראה, contravariance, שמסומנת ב-in, חלה על ממשקים ו-delegates שרק צורכים ערכים: אפשר להשתמש ב-Action<Animal> במקום שבו מצופה Action<Dog>, כי כל מה שיכול לטפל בכל חיה יכול לטפל בכלב. IComparer<in T> הוא contravariant, ו-Func<in T, out TResult> משתמש בשני הסימונים. variance חלה רק על ממשקים ו-delegates, ורק על ארגומנטים שהם טיפוסי הפניה: IEnumerable<int> לא מומר ל-IEnumerable<object>.

טעויות נפוצות

• שימוש ב-object במקום שבו צריך פרמטר טיפוס. זה מוותר על בדיקות בזמן קומפילציה ומבצע boxing לטיפוסי ערך.
• השוואה של שני ערכי T עם ==. בלי אילוץ class זה לא מתקמפל (CS0019), ועם אילוץ כזה זה משווה הפניות. השתמשו ב-EqualityComparer<T>.Default.Equals(a, b), שעובד לכל T ומכבד את ה-Equals של הטיפוס עצמו.
• החזרת default(T) בתור "לא נמצא". זה דו-משמעי בטיפוסי ערך. השתמשו ב-bool TryX(..., out T value).
• יותר מדי אילוצים. כל אחד מצמצם את מי שיכול להשתמש במתודה. הגבילו רק את מה שהגוף באמת צריך.
• ציפייה ש-List<Derived> יומר ל-List<Base>. קבלו במקום זאת IEnumerable<Base> או IReadOnlyList<Base>.