Çalıştırılabilir C# Dokümanları: Generics

Q: C#'ta generic bir metot nasıl yazılır?

Tip parametrelerini metot adından sonra yazın: static T Largest (List items) where T : IComparable { ... }. Çağıranlar genellikle tip argümanını yazmaz, çünkü derleyici onu argümanlardan çıkarır: prices bir List ise Largest(prices) çalışır. Çıkarılacak bir şey olmadığında onu açıkça yazın: Largest (...).

Q: C#'ta where T : class ne anlama gelir?

Bir kısıttır: T bir referans tipi olmalıdır, bu yüzden generic kod bir T'ye null atayabilir ve as T kullanabilir. Diğer kısıtlar where T : struct (nullable olmayan bir değer tipi), where T : new() (public parametresiz bir constructor'ı vardır, böylece kod new T() çağırabilir), where T : SomeBaseClass ve kodun T üzerinde o interface'in üyelerini çağırmasını sağlayan where T : ISomeInterface'tir.

Q: C#'ta default(T) nedir?

T hangi tip olursa olsun onun varsayılan değeridir: sayılar için 0, bool için false, referans tipleri ve nullable tipler için null, diğer değer tipleri için sıfırlanmış bir struct. Generic kod, tipi bilmeden "değer yok"a ihtiyaç duyduğunda onu kullanır; örneğin başarısız bir aramanın dönüş değeri olarak. C# 7.1 daha kısa default literal'ini ekledi.

Q: C#'ta neden bir List 'u bir List 'a atayamıyorum?

Çünkü bir List her hayvanı kabul eder: atamaya izin verilseydi kod aslında bir List olan şeye bir Cat ekleyebilirdi. Derleyici bunu reddeder (CS0029). Salt okunur interface'ler kovaryanttır, bu yüzden IEnumerable animals = dogs; ve IReadOnlyList animals = dogs; ikisi de derlenir, çünkü onların üzerinden hiçbir şey eklenemez.

Generics, bir tipi ya da metodu bir kez yazıp tip güvenliğini kaybetmeden birçok tiple kullanmanızı sağlar. Cast gerektiren ve her şeyi kabul eden bir object List'i yerine, her biri derleyici tarafından kontrol edilen List<int> ve List<Order> elde edersiniz. Açılı parantezlerdeki yer tutucu, geleneksel olarak T, bir tip parametresidir; bir çağıranın sağladığı tip ise tip argümanıdır.

Neden generics: çözdükleri sorun

Generics'ten önce (C# 1) koleksiyonlar object saklardı. Bu derlenirdi, ama hatalar yalnızca çalışma zamanında ortaya çıkardı ve her int içeri girerken box'lanırdı:

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> ile ikinci Add bir derleme hatasıdır, döngü cast gerektirmez ve decimal'ler decimal olarak saklanır.

Generic sınıflar

Tip parametrelerini sınıf adından sonra bildirin, sonra onları sınıfın içinde diğer tipler gibi kullanın:

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

Çıktı:

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

Page<string> ve Page<int> tek bir tanımdan üretilmiş iki farklı tiptir. Bir sınıf birkaç tip parametresi alabilir (Dictionary<TKey, TValue>); tek bir tane varsa T, birkaç tane varsa TSomething olarak adlandırın.

Generic metotlar ve tip çıkarımı

Bir metodun, sınıfı generic olsun ya da olmasın, kendi tip parametreleri olabilir. Çağıranlar genellikle tip argümanını yazmaz, çünkü derleyici onu argümanlardan çıkarır:

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

Çıktı:

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

Çıkarım yalnızca argümanlardan çalışır, asla dönüş tipinden çalışmaz. Repeat(0, 3) işaret gerektirmez, ama T Create<T>() gibi bir metodun çıkaracağı bir şey yoktur, bu yüzden çağıranlar Create<Customer>() yazmalıdır. LINQ'in çoğu bu çıkarıma dayanan generic metotlardır: prices.Where(p => p > 1) siz yazmadan Where<decimal>'dır.

Kısıtlar: T'nin ne olmasına izin verildiği

Generic bir metodun içinde derleyici yalnızca her olası T için çalışanı yapmanıza izin verir. Kısıt olmadan bu, object'in desteklediğinden biraz fazlasıdır. CompareTo çağırmak, bir örnek oluşturmak ya da bir property okumak için derleyiciye T'nin ne olması gerektiğini where ile söyleyin:

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

Çıktı:

17
plum
19.99
42 Zoe

Kullanacağınız kısıtlar:

Kısıt	Anlamı	İzin verdiği
`where T : class`	referans tipi	`null` atamak, `as` kullanmak
`where T : struct`	nullable olmayan değer tipi	`T?`'yi `Nullable<T>` olarak kullanmak
`where T : new()`	public parametresiz constructor	`new T()` çağırmak (en son yazılmalı)
`where T : Entity`	`Entity`'den türer	`Entity`'nin üyelerini kullanmak
`where T : IComparable<T>`	interface'i uygular	`CompareTo` çağırmak
`where T : U`	başka bir tip parametresinden türer	iki parametreyi ilişkilendirmek
`where T : unmanaged` (C# 7.3)	içinde referans olmayan struct	pointer'lar, `stackalloc`
`where T : Enum` (C# 7.3)	bir enum tipi	`Enum` metotlarına geçirmek
`where T : notnull` (C# 8)	nullable olmayan tip	nullable referans işaretlemeleri

Tek bir parametredeki birkaç kısıt virgülle ayrılır; birkaç parametrenin her biri kendi where cümlesini alır: class Cache<TKey, TValue> where TKey : notnull where TValue : class.

Eksik bir kısıt, üyeyi kullandığınız noktada bir derleme hatası olarak ortaya çıkar; örneğin CS1061 ('T' does not contain a definition for 'CompareTo') ya da new() olmadan new T() çağırırken CS0304.

default(T)

Generic kod bazen bilmediği bir tipin "boş değerine" ihtiyaç duyar. default(T) sayılar için 0, bool için false, referans tipleri ve nullable tipler için null, diğer durumlarda sıfırlanmış bir struct verir:

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

Çıktı:

31
0
Porto
True
0001-01-01

İkinci satır bu kalıbın zayıflığını gösterir: değer tipleri için "bulunamadı" ile "0 bulundu" aynı görünür. Framework metotlarının bunun yerine TryGet şeklini (bool TryGetValue(TKey key, out TValue value)) kullanmasının nedeni budur. C# 7.1'den beri, tip bağlamdan belli olduğunda daha kısa return default; yazabilirsiniz.

Statik üyeler oluşturulan tip başınadır

Oluşturulan her tip (Counter<int>, Counter<string>) sınıfın statik alanlarının kendi kopyasını alır:

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

Çıktı:

2
1
False

Bu bazen işe yarar (her T için bir kez hesaplanan TypeInfo<T>.Name gibi tip başına bir önbellek), bazen de paylaşılan tek bir sayaç beklediğinizde bir sürprizdir. Paylaşılan durumu generic olmayan bir sınıfa koyun.

Generic koleksiyonlar

Generic koleksiyonlar çoğu ihtiyacı karşılar: List<T>, Dictionary<TKey, TValue>, HashSet<T>, Queue<T>, Stack<T> ve paylaştıkları interface'ler IEnumerable<T>, ICollection<T>, IList<T>, IReadOnlyList<T>. Bir metodun ihtiyaç duyduğu en dar interface'i kabul edin (yalnızca döngü kuruyorsa IEnumerable<T>) ve somut ya da salt okunur bir tip döndürün.

Kovaryans ve kontravaryans

Bir Dog bir Animal'dır, ama bir List<Dog> bir List<Animal> değildir:

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

Buna izin verilseydi animals.Add(new Cat()) köpek listesine bir kedi koyardı. Yalnızca değer üreten interface'ler güvenlidir ve out ile kovaryant bildirilir:

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

Ayna görüntüsü olan ve in ile işaretlenen kontravaryans, yalnızca değer tüketen interface'lere ve delegelere uygulanır: bir Action<Animal>, bir Action<Dog>'un beklendiği yerde kullanılabilir, çünkü her hayvanı ele alabilen her şey bir köpeği de ele alabilir. IComparer<in T> kontravaryanttır ve Func<in T, out TResult> iki işareti de kullanır. Varyans yalnızca interface'lere ve delegelere ve yalnızca referans tipi argümanlarına uygulanır: IEnumerable<int>, IEnumerable<object>'e dönüşmez.

Yaygın hatalar

Bir tip parametresinin olması gereken yerde object kullanmak. Derleme zamanı kontrollerinden vazgeçer ve değer tiplerini box'lar.
İki T değerini == ile karşılaştırmak. Bir class kısıtı olmadan derlenmez (CS0019), bir tane varsa referansları karşılaştırır. Her T için çalışan ve tipin kendi Equals'ına uyan EqualityComparer<T>.Default.Equals(a, b)'yi kullanın.
"Bulunamadı" olarak default(T) döndürmek. Değer tipleri için belirsizdir. bool TryX(..., out T value) kullanın.
Çok fazla kısıt. Her biri metodu kimin kullanabileceğini daraltır. Yalnızca gövdenin gerçekten ihtiyaç duyduğunu kısıtlayın.
List<Derived>'ın List<Base>'e dönüşmesini beklemek. Bunun yerine IEnumerable<Base> ya da IReadOnlyList<Base> kabul edin.

Sıkça Sorulan Sorular

C#'ta generics nedir?

Generics, bir class'ı, interface'i ya da metodu, çağıranların doldurduğu T gibi bir yer tutucu tiple bir kez yazmanızı sağlar: List<int>, List<Customer>. Derleyici her kullanımı gerçek tipe karşı kontrol eder, böylece cast olmadan tip güvenliği elde edersiniz ve değer tipleri boxing olmadan saklanır. System.Collections.Generic içindeki koleksiyonlar en tanıdık örnektir.

C#'ta generic bir metot nasıl yazılır?

Tip parametrelerini metot adından sonra yazın: static T Largest<T>(List<T> items) where T : IComparable<T> { ... }. Çağıranlar genellikle tip argümanını yazmaz, çünkü derleyici onu argümanlardan çıkarır: prices bir List<decimal> ise Largest(prices) çalışır. Çıkarılacak bir şey olmadığında onu açıkça yazın: Largest<decimal>(...).

C#'ta where T : class ne anlama gelir?

Bir kısıttır: T bir referans tipi olmalıdır, bu yüzden generic kod bir T'ye null atayabilir ve as T kullanabilir. Diğer kısıtlar where T : struct (nullable olmayan bir değer tipi), where T : new() (public parametresiz bir constructor'ı vardır, böylece kod new T() çağırabilir), where T : SomeBaseClass ve kodun T üzerinde o interface'in üyelerini çağırmasını sağlayan where T : ISomeInterface'tir.

C#'ta default(T) nedir?

T hangi tip olursa olsun onun varsayılan değeridir: sayılar için 0, bool için false, referans tipleri ve nullable tipler için null, diğer değer tipleri için sıfırlanmış bir struct. Generic kod, tipi bilmeden "değer yok"a ihtiyaç duyduğunda onu kullanır; örneğin başarısız bir aramanın dönüş değeri olarak. C# 7.1 daha kısa default literal'ini ekledi.

C#'ta neden bir List<Dog>'u bir List<Animal>'a atayamıyorum?

Çünkü bir List<Animal> her hayvanı kabul eder: atamaya izin verilseydi kod aslında bir List<Dog> olan şeye bir Cat ekleyebilirdi. Derleyici bunu reddeder (CS0029). Salt okunur interface'ler kovaryanttır, bu yüzden IEnumerable<Animal> animals = dogs; ve IReadOnlyList<Animal> animals = dogs; ikisi de derlenir, çünkü onların üzerinden hiçbir şey eklenemez.

İlgili kavramlar