C# ジェネリックとは？使い方・メリット・制約を初心者向けに徹底解説

はじめに

C#でプログラムを書いていると、List<string>やDictionary<int, string>のように、型名の後ろへ< >を付けたコードを頻繁に目にします。この仕組みが「ジェネリック」です。

ジェネリックを使うと、処理の内容は共通化しながら、扱うデータ型だけを後から指定できます。たとえば、文字列を保存するクラスと整数を保存するクラスを別々に作らなくても、1つのジェネリッククラスで両方に対応できます。

ジェネリックには、次のようなメリットがあります。

• コンパイル時に型の間違いを検出できる

• 同じ処理を複数の型で再利用できる

• 不要なキャストを減らせる

• 値型を扱う際のボックス化を避けられる

• 共通処理を保守しやすくなる

一方で、型パラメーターに対して使用できる操作や、where句による制約など、初心者がつまずきやすいポイントもあります。

この記事では、C#のジェネリックとは何か、基本的な使い方、メリット、制約、実用例、注意点まで、サンプルコードを交えながら解説します。

1. C#のジェネリックとは？

1-1. ジェネリックの基本概念：型を後から指定できる仕組み

C#のジェネリックとは、クラスやメソッドを定義するときに具体的なデータ型を固定せず、使用時に型を指定できる仕組みです。

たとえば、値を1つ保存するクラスを考えてみましょう。文字列専用のクラスを作る場合は、次のように記述できます。

C#
public class StringBox
{
    public string Value { get; set; }
}

整数も保存したくなった場合、ジェネリックを使わなければ別のクラスが必要です。

C#
public class IntBox
{
    public int Value { get; set; }
}

この2つのクラスは、扱う型が違うだけで構造は同じです。ジェネリックを使えば、次のように1つのクラスへまとめられます。

C#
public class Box<T>
{
    public T Value { get; set; }
}

使用時に、Tへ具体的な型を指定します。

C#
Box<string> stringBox = new Box<string>();
stringBox.Value = "C#";

Box<int> intBox = new Box<int>();
intBox.Value = 100;

Box<string>ではTがstringに、Box<int>ではTがintに置き換わります。

このように、処理や構造を共通化しながら、データ型だけを後から決められることがジェネリックの基本です。

1-2. なぜジェネリックが必要なのか

ジェネリックが必要とされる主な理由は、型安全性とコードの再利用性を両立するためです。

型ごとに同じクラスやメソッドを作る方法でも処理は実現できます。しかし、対応する型が増えるたびに似たコードを追加しなければなりません。

C#
public int GetFirst(int[] values)
{
    return values[0];
}

public string GetFirst(string[] values)
{
    return values[0];
}

この方法では、doubleやDateTimeにも対応したくなると、さらにオーバーロードを追加する必要があります。

ジェネリックメソッドを使えば、1つの定義で複数の型に対応できます。

C#
public T GetFirst<T>(T[] values)
{
    return values[0];
}

使用例は次のとおりです。

C#
int number = GetFirst(new[] { 10, 20, 30 });
string name = GetFirst(new[] { "田中", "佐藤", "鈴木" });

同じロジックを何度も書かずに済むため、修正箇所も少なくなります。型を間違えた場合はコンパイル時に検出されるので、実行時エラーの防止にもつながります。

1-3. 型パラメーター「T」の意味

ジェネリックでよく使われるTは、具体的な型の代わりとなる「型パラメーター」です。一般的に、Tは「Type」の頭文字として使われます。

C#
public class Box<T>
{
    public T Value { get; set; }
}

ここでのTは変数ではなく、型を表すための仮の名前です。

C#
Box<string> box = new Box<string>();

このコードでは、Tがstringとして扱われます。そのため、Valueプロパティの型もstringになります。

C#
box.Value = "Hello";

次のように整数を代入すると、コンパイルエラーになります。

C#
box.Value = 123; // コンパイルエラー

型パラメーター名はTである必要はありません。用途が分かる名前を付けることもできます。

C#
public class Result<TData>
{
    public TData Data { get; set; }
}

複数の型パラメーターを使う場合は、役割に応じて次のような名前がよく使われます。

• TKey：キーの型

• TValue：値の型

• TResult：戻り値の型

• TItem：要素の型

• TEntity：エンティティの型

1-4. object型やオーバーロードとの違い

さまざまな型を扱う方法として、ジェネリック以外にobject型やメソッドのオーバーロードがあります。

object型は、ほぼすべての型の値を受け取れます。

C#
public class ObjectBox
{
    public object Value { get; set; }
}

次のように、文字列と整数のどちらも代入できます。

C#
ObjectBox box = new ObjectBox();

box.Value = "C#";
box.Value = 100;

柔軟に見えますが、値を取り出すときにキャストが必要です。

C#
box.Value = "C#";

string text = (string)box.Value;

型を間違えると、実行時に例外が発生します。

C#
box.Value = "C#";

int number = (int)box.Value; // 実行時に例外

一方、ジェネリックでは使用時に型が決まるため、不正な代入をコンパイル時に検出できます。

C#
Box<string> box = new Box<string>();
box.Value = "C#";

string text = box.Value;

オーバーロードは、引数の型や数が異なる同名メソッドを複数定義する仕組みです。

C#
public void Print(int value)
{
    Console.WriteLine(value);
}

public void Print(string value)
{
    Console.WriteLine(value);
}

型ごとに処理内容が異なる場合は、オーバーロードが適しています。一方、型が違っても同じ処理を行う場合は、ジェネリックの方が重複を減らせます。

C#
public void Print<T>(T value)
{
    Console.WriteLine(value);
}

1-5. C#でジェネリックが使われる代表的な場面

C#では、標準ライブラリの多くにジェネリックが使われています。代表例は次のとおりです。

C#
List<string> names = new List<string>();
Dictionary<int, string> users = new Dictionary<int, string>();
Queue<int> numbers = new Queue<int>();
Stack<DateTime> dates = new Stack<DateTime>();

また、次のような場面でも利用されます。

• 複数の型で共通利用するクラス

• 配列やコレクションの検索処理

• データの変換処理

• APIレスポンスを表すクラス

• Repositoryパターン

• イベントやコールバック

• LINQ

• 非同期処理の戻り値

• 成功・失敗を表す結果クラス

たとえば、APIの結果を共通化するクラスは次のように定義できます。

C#
public class ApiResponse<T>
{
    public bool IsSuccess { get; set; }

    public string Message { get; set; }

    public T Data { get; set; }
}

使用時に、取得するデータの型を指定します。

C#
ApiResponse<User> userResponse = new ApiResponse<User>();
ApiResponse<List<Product>> productResponse =
    new ApiResponse<List<Product>>();

2. C#ジェネリックのメリット

2-1. 型安全にコードを書ける

ジェネリックの大きなメリットは、型の間違いをコンパイル時に検出できることです。

たとえば、文字列専用のリストを作成した場合、文字列以外の値は追加できません。

C#
List<string> names = new List<string>();

names.Add("田中");
names.Add("佐藤");
names.Add(100); // コンパイルエラー

コレクションに保存される型が保証されているので、取り出すときも安全です。

C#
string name = names[0];

object型を使ったコレクションでは、格納されている値の型を開発者が確認しなければなりません。ジェネリックを使えば、コンパイラが型をチェックしてくれます。

その結果、次のような問題を防ぎやすくなります。

• 間違った型の値を代入する

• 不正なキャストを行う

• 想定外の型がコレクションに混入する

• 実行時にInvalidCastExceptionが発生する

2-2. 同じ処理を複数の型で再利用できる

ジェネリックを使うと、型だけが異なる同一処理を共通化できます。

2つの値を入れ替えるメソッドを例に見てみましょう。

C#
public static void Swap<T>(ref T first, ref T second)
{
    T temporary = first;
    first = second;
    second = temporary;
}

このメソッドは、整数や文字列を含むさまざまな型で利用できます。

C#
int a = 10;
int b = 20;

Swap(ref a, ref b);

string firstName = "田中";
string secondName = "佐藤";

Swap(ref firstName, ref secondName);

ジェネリックを使わない場合は、型ごとに同じ内容のメソッドを定義しなければなりません。共通化によってコード量を減らし、修正漏れも防げます。

2-3. キャストを減らしてコードを読みやすくできる

object型で値を扱う場合、取り出すたびにキャストが必要になることがあります。

C#
object value = "C#";
string text = (string)value;

複数の要素を扱うコードでキャストが増えると、処理の本質が分かりにくくなります。

ジェネリックを使えば、値を取り出すときのキャストが不要です。

C#
Box<string> box = new Box<string>();
box.Value = "C#";

string text = box.Value;

コードを読むだけで、どの型を扱っているかが明確になります。IDEの入力補完も正しい型に基づいて動作するため、開発効率の向上にもつながります。

2-4. ボックス化・アンボックス化を避けてパフォーマンスを改善できる

intやdoubleなどの値型をobject型として扱うと、ボックス化が発生します。

C#
int number = 100;
object value = number;

ボックス化とは、値型の値をobject型などの参照型として扱えるように変換する処理です。再び値型へ戻す処理は、アンボックス化と呼ばれます。

C#
int result = (int)value;

大量のデータを繰り返し処理する場合、ボックス化とアンボックス化は余分な処理やメモリ割り当ての原因になる可能性があります。

ジェネリックコレクションでは、値型をその型のまま扱えます。

C#
List<int> numbers = new List<int>();

numbers.Add(100);

int result = numbers[0];

通常はobjectへの変換が不要なので、非ジェネリックコレクションより効率的に値型を扱えます。

ただし、実際のパフォーマンスは処理内容やデータ量によって異なります。小規模な処理では差が目立たない場合もありますが、ジェネリックを使うことには型安全性や可読性という利点もあります。

2-5. 保守性の高い共通処理を作れる

型ごとに同じコードを作ると、不具合修正や仕様変更の際にすべてのコードを変更しなければなりません。

ジェネリックで共通化しておけば、変更箇所を1か所に集約できます。

C#
public class Result<T>
{
    public bool IsSuccess { get; private set; }

    public T Value { get; private set; }

    public string ErrorMessage { get; private set; }

    public static Result<T> Success(T value)
    {
        return new Result<T>
        {
            IsSuccess = true,
            Value = value
        };
    }

    public static Result<T> Failure(string errorMessage)
    {
        return new Result<T>
        {
            IsSuccess = false,
            ErrorMessage = errorMessage
        };
    }
}

このクラスは、さまざまな処理の結果を共通形式で表せます。

C#
Result<int> numberResult = Result<int>.Success(100);

Result<string> textResult =
    Result<string>.Failure("データを取得できませんでした");

共通のルールを一元管理できるため、コード全体の一貫性も保ちやすくなります。

3. C#ジェネリックの基本的な使い方

3-1. ジェネリッククラスの書き方

ジェネリッククラスは、クラス名の後ろに型パラメーターを記述して定義します。

C#
public class Box<T>
{
    private T _value;

    public void SetValue(T value)
    {
        _value = value;
    }

    public T GetValue()
    {
        return _value;
    }
}

使用時に具体的な型を指定します。

C#
Box<string> textBox = new Box<string>();

textBox.SetValue("ジェネリック");
string text = textBox.GetValue();

整数を扱う場合は、同じクラスへintを指定します。

C#
Box<int> numberBox = new Box<int>();

numberBox.SetValue(123);
int number = numberBox.GetValue();

Box<string>とBox<int>は、同じジェネリッククラスをもとにしていますが、C#上では異なる型として扱われます。

3-2. ジェネリックメソッドの書き方

ジェネリックメソッドは、メソッド名の後ろに型パラメーターを記述します。

C#
public static T GetFirst<T>(T[] values)
{
    if (values == null)
    {
        throw new ArgumentNullException(nameof(values));
    }

    if (values.Length == 0)
    {
        throw new ArgumentException(
            "配列に要素がありません。",
            nameof(values));
    }

    return values[0];
}

呼び出すときは、型を明示できます。

C#
int firstNumber = GetFirst<int>(new[] { 10, 20, 30 });

string firstName =
    GetFirst<string>(new[] { "田中", "佐藤" });

引数から型を判断できる場合は、型指定を省略できます。

C#
int firstNumber = GetFirst(new[] { 10, 20, 30 });
string firstName = GetFirst(new[] { "田中", "佐藤" });

通常のクラス内にジェネリックメソッドだけを定義することも可能です。

C#
public class Converter
{
    public string ToText<T>(T value)
    {
        return value?.ToString() ?? string.Empty;
    }
}

3-3. ジェネリックインターフェイスの書き方

インターフェイスにも型パラメーターを指定できます。

C#
public interface IRepository<T>
{
    T FindById(int id);

    void Add(T item);

    IReadOnlyList<T> GetAll();
}

Userを扱う実装クラスは、次のように定義できます。

C#
public class User
{
    public int Id { get; set; }

    public string Name { get; set; }
}

C#
public class UserRepository : IRepository<User>
{
    private readonly List<User> _users = new List<User>();

    public User FindById(int id)
    {
        return _users.FirstOrDefault(user => user.Id == id);
    }

    public void Add(User item)
    {
        _users.Add(item);
    }

    public IReadOnlyList<User> GetAll()
    {
        return _users;
    }
}

インターフェイス側で共通の契約を定義し、実装時に扱う型を決められるのが特徴です。

3-4. 複数の型パラメーターを使う方法

ジェネリックでは、複数の型パラメーターを指定できます。

C#
public class Pair<TFirst, TSecond>
{
    public TFirst First { get; set; }

    public TSecond Second { get; set; }
}

使用例は次のとおりです。

C#
Pair<int, string> user =
    new Pair<int, string>
    {
        First = 1,
        Second = "田中"
    };

メソッドでも複数の型を使用できます。

C#
public static TResult ConvertValue<TSource, TResult>(
    TSource source,
    Func<TSource, TResult> converter)
{
    return converter(source);
}

呼び出し例は次のとおりです。

C#
int length = ConvertValue<string, int>(
    "C#",
    text => text.Length);

型パラメーターが複数ある場合は、T1やT2よりも、TSourceやTResultなど役割が分かる名前を付けると読みやすくなります。

3-5. 型推論で型指定を省略できるケース

ジェネリックメソッドでは、引数から型を判断できる場合、型パラメーターの指定を省略できます。

C#
public static T Echo<T>(T value)
{
    return value;
}

次のコードでは、引数がstringなので、コンパイラはTをstringだと推論します。

C#
string text = Echo("Hello");

整数の場合はintと推論されます。

C#
int number = Echo(100);

型を明示しても問題ありません。

C#
string text = Echo<string>("Hello");

ただし、戻り値だけから型を推論することは基本的にできません。

C#
public static T Create<T>()
{
    return default;
}

次の呼び出しでは、引数がないためTを判断できません。

C#
// string text = Create(); // 型を推論できない

この場合は型を明示します。

C#
string text = Create<string>();

4. ジェネリックの実用例

4-1. List<T>で学ぶジェネリックコレクション

List<T>は、指定した型の要素を順番に保持するジェネリックコレクションです。

C#
List<string> names = new List<string>();

names.Add("田中");
names.Add("佐藤");
names.Add("鈴木");

Tにstringを指定しているため、リストへ追加できるのは文字列だけです。

要素はインデックスやforeachで取得できます。

C#
string firstName = names[0];

foreach (string name in names)
{
    Console.WriteLine(name);
}

整数のリストも同じ仕組みで作成できます。

C#
List<int> numbers = new List<int>
{
    10,
    20,
    30
};

int total = numbers.Sum();

List<T>には、追加、削除、検索、並べ替えなどの機能があります。

C#
names.Remove("佐藤");

bool containsTanaka = names.Contains("田中");

names.Sort();

独自クラスを要素にすることもできます。

C#
List<User> users = new List<User>
{
    new User { Id = 1, Name = "田中" },
    new User { Id = 2, Name = "佐藤" }
};

4-2. Dictionary<TKey, TValue>でキーと値の型を指定する

Dictionary<TKey, TValue>は、キーと値の組み合わせを保存するジェネリックコレクションです。

C#
Dictionary<int, string> users =
    new Dictionary<int, string>();

users.Add(1, "田中");
users.Add(2, "佐藤");

この例では、キーがint、値がstringです。

C#
string userName = users[1];

存在しないキーをインデクサーで取得すると例外が発生するため、TryGetValueを使うと安全です。

C#
if (users.TryGetValue(1, out string userName))
{
    Console.WriteLine(userName);
}

独自クラスを値として保存することもできます。

C#
Dictionary<int, User> userMap =
    new Dictionary<int, User>();

userMap[1] = new User
{
    Id = 1,
    Name = "田中"
};

キーと値の型が明確なので、値を取得する際のキャストは不要です。

4-3. 共通の検索・変換処理をジェネリックメソッドにする

ジェネリックメソッドは、検索や変換などの共通処理に向いています。

条件に一致する最初の要素を取得するメソッドは、次のように定義できます。

C#
public static T FindFirst<T>(
    IEnumerable<T> items,
    Func<T, bool> condition)
{
    foreach (T item in items)
    {
        if (condition(item))
        {
            return item;
        }
    }

    return default;
}

整数を検索する例です。

C#
List<int> numbers = new List<int>
{
    10,
    20,
    30
};

int result = FindFirst(numbers, number => number >= 20);

ユーザーを検索する場合も、同じメソッドを利用できます。

C#
User user = FindFirst(
    users,
    item => item.Id == 2);

変換処理もジェネリック化できます。

C#
public static List<TResult> ConvertAll<TSource, TResult>(
    IEnumerable<TSource> source,
    Func<TSource, TResult> converter)
{
    List<TResult> results = new List<TResult>();

    foreach (TSource item in source)
    {
        results.Add(converter(item));
    }

    return results;
}

使用例は次のとおりです。

C#
List<int> lengths = ConvertAll(
    new[] { "C#", "Java", "Python" },
    text => text.Length);

実際の開発では、同様の処理をLINQのFirstOrDefaultやSelectで実現できます。自作の共通処理を設計する際は、標準機能で代用できないか確認することも重要です。

4-4. Repositoryパターンでジェネリッククラスを活用する

Repositoryパターンでは、データの取得や保存といった操作を専用クラスへまとめます。

複数のエンティティで共通する処理は、ジェネリックインターフェイスとして定義できます。

C#
public interface IEntity
{
    int Id { get; set; }
}

C#
public interface IRepository<TEntity>
    where TEntity : IEntity
{
    TEntity FindById(int id);

    IReadOnlyList<TEntity> GetAll();

    void Add(TEntity entity);

    bool Remove(int id);
}

メモリ上へデータを保存する実装例は次のとおりです。

C#
public class InMemoryRepository<TEntity>
    : IRepository<TEntity>
    where TEntity : class, IEntity
{
    private readonly List<TEntity> _items =
        new List<TEntity>();

    public TEntity FindById(int id)
    {
        return _items.FirstOrDefault(
            item => item.Id == id);
    }

    public IReadOnlyList<TEntity> GetAll()
    {
        return _items;
    }

    public void Add(TEntity entity)
    {
        _items.Add(entity);
    }

    public bool Remove(int id)
    {
        TEntity entity = FindById(id);

        if (entity == null)
        {
            return false;
        }

        return _items.Remove(entity);
    }
}

Userクラスで利用する場合は、次のように記述します。

C#
public class User : IEntity
{
    public int Id { get; set; }

    public string Name { get; set; }
}

C#
IRepository<User> repository =
    new InMemoryRepository<User>();

repository.Add(new User
{
    Id = 1,
    Name = "田中"
});

エンティティごとに同じCRUD処理を作る必要がなくなり、共通部分を一元管理できます。

ただし、すべてのデータ操作を無理に1つのジェネリックRepositoryへまとめると、エンティティ固有の検索処理を表現しにくくなる場合があります。共通化する範囲を適切に見極めることが大切です。

4-5. 戻り値や引数にジェネリックを使う実践例

ジェネリック型は、メソッドの引数や戻り値として利用できます。

C#
public class ServiceResult<T>
{
    public bool IsSuccess { get; init; }

    public T Data { get; init; }

    public string ErrorMessage { get; init; }
}

ユーザーを取得するメソッドでは、戻り値をServiceResult<User>にします。

C#
public ServiceResult<User> GetUser(int id)
{
    User user = FindUser(id);

    if (user == null)
    {
        return new ServiceResult<User>
        {
            IsSuccess = false,
            ErrorMessage = "ユーザーが見つかりません。"
        };
    }

    return new ServiceResult<User>
    {
        IsSuccess = true,
        Data = user
    };
}

一覧を返す場合は、ジェネリック型の中へ別のジェネリック型を指定できます。

C#
public ServiceResult<List<User>> GetUsers()
{
    List<User> users = LoadUsers();

    return new ServiceResult<List<User>>
    {
        IsSuccess = true,
        Data = users
    };
}

引数へジェネリック型を使用する例は次のとおりです。

C#
public void PrintResult<T>(ServiceResult<T> result)
{
    if (result.IsSuccess)
    {
        Console.WriteLine(result.Data);
    }
    else
    {
        Console.WriteLine(result.ErrorMessage);
    }
}

5. ジェネリック制約とは？

5-1. where句で型パラメーターに条件を付ける

ジェネリック制約とは、型パラメーターとして指定できる型に条件を付ける仕組みです。

制約はwhere句で指定します。

C#
public class Repository<T>
    where T : class
{
}

この例では、Tに指定できるのは参照型だけです。

制約を付ける主な目的は、次の2つです。

1. 使用できる型を限定する

2. 型パラメーターに対して特定のメンバーを呼び出せるようにする

たとえば、すべての型がIdプロパティを持っているとは限りません。そのため、制約なしのTからIdを参照することはできません。

C#
public int GetId<T>(T item)
{
    // return item.Id; // コンパイルエラー
    return 0;
}

Idを定義したインターフェイスで制約すると、参照できるようになります。

C#
public interface IEntity
{
    int Id { get; }
}

C#
public int GetId<T>(T item)
    where T : IEntity
{
    return item.Id;
}

5-2. class制約とstruct制約の違い

class制約は、型パラメーターを参照型に限定します。

C#
public class ReferenceBox<T>
    where T : class
{
    public T Value { get; set; }
}

次の指定は可能です。

C#
ReferenceBox<string> textBox =
    new ReferenceBox<string>();

ReferenceBox<User> userBox =
    new ReferenceBox<User>();

intなどの値型は指定できません。

C#
// ReferenceBox<int> numberBox =
//     new ReferenceBox<int>();

struct制約は、型パラメーターをnull非許容の値型に限定します。

C#
public class ValueBox<T>
    where T : struct
{
    public T Value { get; set; }
}

使用例は次のとおりです。

C#
ValueBox<int> intBox = new ValueBox<int>();
ValueBox<DateTime> dateBox = new ValueBox<DateTime>();

参照型は指定できません。

C#
// ValueBox<string> textBox =
//     new ValueBox<string>();

class制約は参照型を扱う処理、struct制約は値型を扱う処理で利用します。

5-3. new()制約でインスタンス生成を許可する

型パラメーターから新しいインスタンスを生成したい場合は、new()制約を指定します。

C#
public static T Create<T>()
    where T : new()
{
    return new T();
}

new()制約を付けると、引数なしで呼び出せるコンストラクターを持つ型を指定できます。

C#
public class User
{
    public User()
    {
    }

    public string Name { get; set; }
}

C#
User user = Create<User>();

new()制約がなければ、new T()は使用できません。

C#
public static T CreateWithoutConstraint<T>()
{
    // return new T(); // コンパイルエラー
    return default;
}

複数の制約と組み合わせる場合、new()は制約リストの最後に記述します。

C#
public class Factory<T>
    where T : class, IEntity, new()
{
    public T Create()
    {
        return new T();
    }
}

5-4. インターフェイス制約で使えるメンバーを限定する

インターフェイス制約を使うと、そのインターフェイスを実装した型だけを受け付けられます。

C#
public interface IPrintable
{
    void Print();
}

C#
public static void ExecutePrint<T>(T item)
    where T : IPrintable
{
    item.Print();
}

TがIPrintableを実装していることが保証されるため、Printメソッドを安全に呼び出せます。

C#
public class Report : IPrintable
{
    public void Print()
    {
        Console.WriteLine("レポートを印刷します。");
    }
}

C#
Report report = new Report();
ExecutePrint(report);

インターフェイス制約は、具体的なクラスへ依存せず、必要な機能だけを要求したい場合に適しています。

5-5. 基底クラス制約を使うケース

基底クラス制約では、指定したクラス、またはその派生クラスだけを型パラメーターとして使用できます。

C#
public abstract class Entity
{
    public int Id { get; set; }
}

C#
public class EntityService<T>
    where T : Entity
{
    public int GetId(T entity)
    {
        return entity.Id;
    }
}

UserがEntityを継承していれば、型パラメーターとして指定できます。

C#
public class User : Entity
{
    public string Name { get; set; }
}

C#
EntityService<User> service =
    new EntityService<User>();

基底クラス制約を使うと、基底クラスが持つプロパティやメソッドをジェネリックコード内で利用できます。

ただし、単に特定の機能を要求したいだけであれば、基底クラスよりインターフェイス制約の方が柔軟なことがあります。C#ではクラスの多重継承ができないため、不要に基底クラスを強制しない設計も重要です。

5-6. 複数の制約を組み合わせる書き方

複数の制約は、カンマで区切って指定します。

C#
public class Repository<T>
    where T : class, IEntity, new()
{
    public T Create()
    {
        return new T();
    }

    public int GetId(T entity)
    {
        return entity.Id;
    }
}

この例でTに求められる条件は次のとおりです。

• 参照型である

• IEntityを実装している

• 引数なしで呼び出せるコンストラクターを持つ

複数の型パラメーターへ、それぞれ異なる制約を付けることもできます。

C#
public class Converter<TSource, TResult>
    where TSource : class
    where TResult : class, new()
{
    public TResult Convert(TSource source)
    {
        return new TResult();
    }
}

制約には記述順のルールがあります。代表的には、次の順序を意識します。

1. classやstructなどの制約

2. 基底クラスやインターフェイスの制約

3. new()制約

6. ジェネリックを使うときの注意点・落とし穴

6-1. 型パラメーターでは使えない操作がある

制約のない型パラメーターTについて、コンパイラが保証できる機能は限られています。

たとえば、すべての型で加算演算子が使えるわけではないため、次のコードはそのままではコンパイルできません。

C#
public static T Add<T>(T left, T right)
{
    // return left + right; // コンパイルエラー
    return default;
}

Tがintかもしれませんが、UserやDateTimeかもしれません。そのため、コンパイラは+演算子を使用できると判断できません。

数値演算をジェネリック化するときは、対応する.NETおよびC#の環境で利用可能な数値インターフェイスを制約として使う方法があります。

C#
using System.Numerics;

public static T Add<T>(T left, T right)
    where T : INumber<T>
{
    return left + right;
}

また、比較処理ではIComparable<T>を制約にできます。

C#
public static T Max<T>(T left, T right)
    where T : IComparable<T>
{
    return left.CompareTo(right) >= 0
        ? left
        : right;
}

6-2. 制約なしではメソッドやプロパティを呼び出せない

制約のないTに対しては、その型固有のプロパティやメソッドを使用できません。

C#
public static void ShowName<T>(T item)
{
    // Console.WriteLine(item.Name);
}

Tが必ずNameプロパティを持つとは限らないからです。

必要なメンバーをインターフェイスに定義し、制約として指定します。

C#
public interface IHasName
{
    string Name { get; }
}

C#
public static void ShowName<T>(T item)
    where T : IHasName
{
    Console.WriteLine(item.Name);
}

制約は型を不必要に限定するためのものではなく、ジェネリックコード内で必要な操作を保証するために使います。

6-3. default(T)の挙動に注意する

default(T)は、型パラメーターの既定値を返します。

C#
public static T GetDefault<T>()
{
    return default(T);
}

省略形としてdefaultと書くこともできます。

C#
public static T GetDefault<T>()
{
    return default;
}

既定値は型によって異なります。

C#
int number = GetDefault<int>();       // 0
bool flag = GetDefault<bool>();       // false
DateTime date = GetDefault<DateTime>(); // 既定のDateTime
string text = GetDefault<string>();   // null

検索メソッドで対象が見つからない場合にdefaultを返すと、値によっては「見つからなかった」のか「既定値の要素が見つかった」のか判別しにくくなります。

C#
int result = FindFirst(
    new[] { 0, 1, 2 },
    number => number > 100);