الأنواع العامة Generics في C#: الأصناف والدوال العامة والقيود

تتيح لك الأنواع العامة (generics) كتابة نوع أو دالة مرة واحدة واستخدامها مع أنواع كثيرة، دون فقدان سلامة الأنواع. بدل List من object تحتاج إلى تحويلات وتقبل أي شيء، تحصل على List<int> وList<Order>، كل منها يفحصه المترجم. النائب بين علامتي الزاوية، T عرفًا، معامل نوع؛ والنوع الذي يقدّمه المستدعي وسيط النوع.

لماذا الأنواع العامة: المشكلة التي تحلّها

قبل الأنواع العامة (C# 1) كانت المجموعات تخزّن object. كان ذلك يُترجم، لكن الأخطاء لم تكن تظهر إلا وقت التشغيل، وكان كل int يُغلَّف عند دخوله:

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 الثاني خطأ ترجمة، ولا تحتاج الحلقة إلى تحويل، وتُخزَّن القيم العشرية كقيم عشرية.

الأصناف العامة

صرّح بمعاملات النوع بعد اسم الصنف، ثم استخدمها كأي نوع آخر داخل الصنف:

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 للأنواع المرجعية والأنواع القابلة لـ null، وبنية مصفّرة في غير ذلك:

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" متطابقين. ولهذا تستخدم دوال الإطار شكل 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

هذا مفيد أحيانًا (ذاكرة مؤقتة لكل نوع مثل 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> إن كانت تمرّ فقط)، وأعد نوعًا فعليًا أو للقراءة فقط.

التغاير والتغاير المعاكس

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، ينطبق على الواجهات والمفوّضات التي تستهلك القيم فقط: يمكن استخدام Action<Animal> حيث يُتوقع Action<Dog>، لأن ما يستطيع التعامل مع أي حيوان يستطيع التعامل مع كلب. IComparer<in T> متغايرة معاكسة، وFunc<in T, out TResult> تستخدم العلامتين. ولا ينطبق التغاير إلا على الواجهات والمفوّضات، ولا إلا على وسائط الأنواع المرجعية: لا تتحوّل IEnumerable<int> إلى IEnumerable<object>.

أخطاء شائعة

• استخدام object حيث مكان معامل نوع. يتخلّى عن فحوص وقت الترجمة ويغلّف أنواع القيم.
• مقارنة قيمتي 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> بدلًا من ذلك.