【C#】ジェネリック whereの使い方｜型制約の種類と実践的な活用例を解説

// クラスに対する型制約
public class MyGenericClass<T> where T : constraint
{
    // ...
}

// メソッドに対する型制約
public void MyMethod<T>(T item) where T : constraint
{
    // ...
}

using System;

// 比較可能な型であることを保証するインターフェース制約
public class ComparerExmpale
{
    public static T Max<T>(T a, T b) where T : IComparable<T>
    {
        // IComparable<T>を実装していることが保証されているため、CompareToが呼べる
        return a.CompareTo(b) > 0 ? a : b;
    }
}

class Program
{
    static void Main()
    {
        int resultInt = ComparerExmpale.Max(10, 20);
        string resultStr = ComparerExmpale.Max("Apple", "Banana");

        Console.WriteLine($"Max Int: {resultInt}");
        Console.WriteLine($"Max String: {resultStr}");
    }
}

public class Factory<T> where T : new()
{
    public T CreateInstance()
    {
        // 制約がないと、コンストラクタが存在するか不明なためエラーになる
        return new T();
    }
}

public class DataHandler<T> where T : class
{
    public void CheckNull(T item)
    {
        // Tが参照型であることが保証されているため、nullと比較できる
        if (item == null)
        {
            Console.WriteLine("Item is null");
        }
    }
}

using System;

public class UnmanagedExample
{
    // アンマネージ型のみを受け取り、サイズを表示する
    public static unsafe void PrintSize<T>() where T : unmanaged
    {
        Console.WriteLine($"Size of {typeof(T).Name}: {sizeof(T)} bytes");
    }
}

class Program
{
    static void Main()
    {
        UnmanagedExample.PrintSize<int>();
        UnmanagedExample.PrintSize<double>();
        // UnmanagedExample.PrintSize<string>(); // コンパイルエラー：stringはマネージ型
    }
}

public class Repository<T> 
    where T : class, IEnumerable<T>, new()
{
    public void Process()
    {
        T instance = new T();
        foreach (var item in instance)
        {
            // 列挙可能なクラスとしての処理
        }
    }
}

public class Mapper<TSource, TDest>
    where TSource : class
    where TDest : new()
{
    public TDest Map(TSource source)
    {
        TDest dest = new TDest();
        // マッピング処理
        return dest;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;

// すべてのエンティティが持つべきインターフェース
public interface IEntity
{
    int Id { get; set; }
}

// 具体的なエンティティクラス
public class User : IEntity
{
    public int Id { get; set; }
    public string Name { get; set; }
}

// ジェネリックなリポジトリ
public class GenericRepository<T> where T : class, IEntity, new()
{
    private readonly List<T> _dataStore = new List<T>();

    public void Add(T item)
    {
        _dataStore.Add(item);
        Console.WriteLine($"Added item with ID: {item.Id}");
    }

    public T GetById(int id)
    {
        // IEntity制約があるため、T型のオブジェクトのIdプロパティにアクセスできる
        return _dataStore.FirstOrDefault(x => x.Id == id);
    }
}

class Program
{
    static void Main()
    {
        var userRepo = new GenericRepository<User>();
        userRepo.Add(new User { Id = 1, Name = "Tanaka" });

        var user = userRepo.GetById(1);
        Console.WriteLine($"Retrieved User: {user.Name}");
    }
}

using System;
using System.Numerics; // INumberの利用に必要

public class Calculator
{
    // INumber<T>制約により、数値型全般（int, double, decimalなど）を受け入れ、計算できる
    public static T AddAll<T>(IEnumerable<T> values) where T : INumber<T>
    {
        T sum = T.Zero;
        foreach (var value in values)
        {
            sum += value; // + 演算子が使える！
        }
        return sum;
    }
}

class Program
{
    static void Main()
    {
        int[] nums = { 1, 2, 3, 4, 5 };
        double[] doubles = { 1.1, 2.2, 3.3 };

        Console.WriteLine($"Sum of ints: {Calculator.AddAll(nums)}");
        Console.WriteLine($"Sum of doubles: {Calculator.AddAll(doubles)}");
    }
}