実行できるC#ドキュメント: ジェネリック

Q: C#のジェネリックとは何ですか？

ジェネリックを使うと、クラス、インターフェース、メソッドを、呼び出し側が埋める仮の型 T とともに一度だけ書けます：List 、List 。コンパイラはすべての使用を実際の型に対して確認するので、キャストなしで型安全性が得られ、値型はボックス化されずに格納されます。System.Collections.Generic のコレクションが最もなじみのある例です。

Q: C#でジェネリックメソッドを書くには？

メソッド名の後に型パラメーターを置きます：static T Largest (List items) where T : IComparable { ... }。コンパイラが引数から型引数を推論するので、呼び出し側は通常それを省略します。prices が List なら Largest(prices) で動きます。推論の元になるものがない場合は、Largest (...) と明示的に書きます。

Q: C#のwhere T : classとはどういう意味ですか？

制約で、T は参照型でなければなりません。そのためジェネリックなコードは T に null を代入でき、as T を使えます。他の制約には、where T : struct（null非許容の値型）、where T : new()（公開の引数なしのコンストラクターを持つので、コードが new T() を呼べる）、where T : SomeBaseClass、そして T に対してそのインターフェースのメンバーを呼べるようにする where T : ISomeInterface があります。

Q: C#のdefault(T)とは何ですか？

T が何の型になっても、その既定値です。数値なら 0、bool なら false、参照型とnull許容型なら null、その他の値型ならゼロにされた構造体です。ジェネリックなコードが、型を知らずに「値がない」を必要とするとき、たとえば検索が失敗したときの戻り値に使います。C# 7.1では、より短い default リテラルが追加されました。

Q: C#でList をList に代入できないのはなぜですか？

List はどんな動物でも受け入れるからです。代入が許されると、コードは実際には List であるものに Cat を追加できてしまいます。コンパイラはそれを拒否します（CS0029）。読み取り専用のインターフェースは共変なので、それらを通しては何も追加できないため、IEnumerable animals = dogs; も IReadOnlyList animals = dogs; もコンパイルできます。

ジェネリックを使うと、型やメソッドを一度書くだけで、型安全性を失わずに多くの型で使えます。キャストが必要で何でも受け入れる object の List の代わりに、それぞれコンパイラが確認する 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> なら、2つ目の Add はコンパイルエラーになり、ループにキャストは不要で、decimalはdecimalとして格納されます。

ジェネリッククラス

クラス名の後に型パラメーターを宣言し、クラスの中では他の型と同じように使います。

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> は、1つの定義から作られた2つの異なる型です。クラスは複数の型パラメーターを取れます（Dictionary<TKey, TValue>）。1つなら 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 を呼んだり、インスタンスを作ったり、プロパティを読んだりするには、where で T が何でなければならないかをコンパイラに伝えます。

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 T : class`	参照型	`null` の代入、`as` の使用
`where T : struct`	null非許容の値型	`T?` を `Nullable<T>` として使う
`where T : new()`	公開の引数なしのコンストラクター	`new T()` の呼び出し（最後に書く必要がある）
`where T : Entity`	`Entity` から派生	`Entity` のメンバーを使う
`where T : IComparable<T>`	インターフェースを実装	`CompareTo` の呼び出し
`where T : U`	別の型パラメーターから派生	2つのパラメーターを関連付ける
`where T : unmanaged`（C# 7.3）	中に参照を持たない構造体	ポインター、`stackalloc`
`where T : Enum`（C# 7.3）	enumの型	`Enum` のメソッドに渡す
`where T : notnull`（C# 8）	null非許容の型	null許容参照の注釈

1つのパラメーターに対する複数の制約はカンマで区切り、複数のパラメーターにはそれぞれ独自の where 句を付けます：class Cache<TKey, TValue> where TKey : notnull where TValue : class。

制約が足りないと、メンバーを使った箇所でコンパイルエラーとして現れます。たとえばCS1061（'T' does not contain a definition for 'CompareTo'）や、new() なしで new T() を呼んだ場合のCS0304です。

default(T)

ジェネリックなコードは、知らない型の「空の値」を必要とすることがあります。default(T) は、数値なら 0、bool なら false、参照型と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

2行目はこのパターンの弱点を示しています。値型では「見つからなかった」と「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

これはときどき役に立ち（T ごとに一度だけ計算される TypeInfo<T>.Name のような型ごとのキャッシュ）、共有のカウンターを1つ期待していた場合にはときどき驚かされます。共有の状態はジェネリックでないクラスに置きます。

ジェネリックコレクション

ジェネリックコレクションはほとんどの用途をまかないます。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()) が犬のリストに猫を入れてしまいます。値を生成するだけのインターフェースは安全で、out で共変と宣言されています。

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

その鏡像である反変性は in で示され、値を消費するだけのインターフェースやデリゲートに当てはまります。どんな動物でも扱えるものは犬も扱えるので、Action<Dog> が期待される場所で Action<Animal> を使えます。IComparer<in T> は反変で、Func<in T, out TResult> は両方の印を使っています。変性が当てはまるのはインターフェースとデリゲートだけで、型引数が参照型の場合に限ります。IEnumerable<int> は IEnumerable<object> に変換されません。

よくある間違い

型パラメーターを使うべき場所で object を使う。 コンパイル時のチェックを失い、値型をボックス化します。
2つの T の値を == で比較する。 class 制約がなければコンパイルできず（CS0019）、あれば参照を比較します。すべての T で動き、型自身の Equals を尊重する EqualityComparer<T>.Default.Equals(a, b) を使います。
「見つからない」として default(T) を返す。 値型ではあいまいです。bool TryX(..., out T value) を使います。
制約が多すぎる。 制約の1つ1つが、メソッドを使える人を狭めます。本体が実際に必要とするものだけを制約します。
List<Derived> が List<Base> に変換されると思う。 代わりに IEnumerable<Base> か IReadOnlyList<Base> を受け取ります。

よくある質問

C#のジェネリックとは何ですか？

ジェネリックを使うと、クラス、インターフェース、メソッドを、呼び出し側が埋める仮の型 T とともに一度だけ書けます：List<int>、List<Customer>。コンパイラはすべての使用を実際の型に対して確認するので、キャストなしで型安全性が得られ、値型はボックス化されずに格納されます。System.Collections.Generic のコレクションが最もなじみのある例です。

C#でジェネリックメソッドを書くには？

メソッド名の後に型パラメーターを置きます：static T Largest<T>(List<T> items) where T : IComparable<T> { ... }。コンパイラが引数から型引数を推論するので、呼び出し側は通常それを省略します。prices が List<decimal> なら Largest(prices) で動きます。推論の元になるものがない場合は、Largest<decimal>(...) と明示的に書きます。

C#のwhere T : classとはどういう意味ですか？

制約で、T は参照型でなければなりません。そのためジェネリックなコードは T に null を代入でき、as T を使えます。他の制約には、where T : struct（null非許容の値型）、where T : new()（公開の引数なしのコンストラクターを持つので、コードが new T() を呼べる）、where T : SomeBaseClass、そして T に対してそのインターフェースのメンバーを呼べるようにする where T : ISomeInterface があります。

C#のdefault(T)とは何ですか？

T が何の型になっても、その既定値です。数値なら 0、bool なら false、参照型とnull許容型なら null、その他の値型ならゼロにされた構造体です。ジェネリックなコードが、型を知らずに「値がない」を必要とするとき、たとえば検索が失敗したときの戻り値に使います。C# 7.1では、より短い default リテラルが追加されました。

C#でList<Dog>をList<Animal>に代入できないのはなぜですか？

List<Animal> はどんな動物でも受け入れるからです。代入が許されると、コードは実際には List<Dog> であるものに Cat を追加できてしまいます。コンパイラはそれを拒否します（CS0029）。読み取り専用のインターフェースは共変なので、それらを通しては何も追加できないため、IEnumerable<Animal> animals = dogs; も IReadOnlyList<Animal> animals = dogs; もコンパイルできます。