【C#】ジェネリック完全ガイド｜where制約・共変性・IComparable・default(T)・静的メンバーまで

// 問題①: 型安全でない（実行時エラー）
var list = new System.Collections.ArrayList();
list.Add(1);
list.Add("text");             // 異なる型でも追加できてしまう
int n = (int)list[1];         // InvalidCastException: 実行時に初めて分かる

// 問題②: 値型のボクシングでパフォーマンス劣化
list.Add(42);                 // int → object へのボクシング（ヒープアロケーション）
int x = (int)list[0];         // object → int へのアンボクシング

// List<T>: 両方の問題を解決
var nums = new List<int>();
nums.Add(42);                 // ボクシングなし（int のまま格納）
// nums.Add("text");          // コンパイルエラー → 実行前に気づける
int y = nums[0];              // キャスト不要

// 単一型パラメーター
public class Box<T>
{
    private T _value;

    public Box(T value) => _value = value;
    public T Value => _value;
    public override string ToString() => $"Box({_value})";
}

// 複数の型パラメーター（型パラメーター名に意味をもたせる）
public class Pair<TFirst, TSecond>
{
    public TFirst  First  { get; init; }
    public TSecond Second { get; init; }

    public Pair(TFirst first, TSecond second)
        => (First, Second) = (first, second);

    // 型パラメーターを逆にしたペアを返すジェネリックメソッド
    public Pair<TSecond, TFirst> Swap() => new(Second, First);
}

// 使い方
var box1 = new Box<string>("Hello");
var box2 = new Box<int>(42);
Console.WriteLine(box1.Value);         // Hello
Console.WriteLine(box2.Value);         // 42

var pair = new Pair<string, int>("Alice", 30);
Console.WriteLine(pair.First);         // Alice
var swapped = pair.Swap();
Console.WriteLine(swapped.First);      // 30（int）

// ジェネリックメソッドの定義（クラスとは独立した型パラメーター）
static T Max<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) >= 0 ? a : b;

// 型推論: int と推論される（<int> を明示しなくてよい）
int    result1 = Max(10, 20);           // 20（T = int と推論）
string result2 = Max("apple", "banana"); // "banana"（T = string と推論）

// 型推論できない場合は明示する
static TOut Convert<TIn, TOut>(TIn value, Func<TIn, TOut> converter)
    => converter(value);

// TIn = string は引数から推論できるが TOut = int は推論できないので明示
int len = Convert<string, int>("Hello", s => s.Length);  // 5

// 汎用スワップ: ref で値を入れ替える
static void Swap<T>(ref T a, ref T b) => (a, b) = (b, a);

int x = 1, y = 2;
Swap(ref x, ref y);
Console.WriteLine($"x={x}, y={y}");  // x=2, y=1

// struct 制約: 値型のみ受け入れる（Nullable<T> と同じ原理）
public class ValueContainer<T> where T : struct
{
    public T?   Value    { get; set; }   // T? は値型の場合に Nullable<T> になる
    public bool HasValue => Value.HasValue;
}

// new() 制約: new T() で実体化できる
public class Factory<T> where T : class, new()
{
    public T Create() => new T();
    public List<T> CreateMany(int count)
        => Enumerable.Range(0, count).Select(_ => new T()).ToList();
}

// 複数の制約を組み合わせる（カンマ区切りで AND 条件）
public class SortedRepository<T>
    where T : class, IComparable<T>, new()
{
    private readonly List<T> _items = new();

    public void Add(T item)
    {
        _items.Add(item);
        _items.Sort((a, b) => a.CompareTo(b)); // IComparable<T> のメンバーを使える
    }

    public T? Min() => _items.Count > 0 ? _items[0] : null;
}

// unmanaged 制約: 参照を含まない値型のみ（int, float, struct of only value types）
static unsafe int SizeOf<T>() where T : unmanaged => sizeof(T);
Console.WriteLine(SizeOf<int>());    // 4
Console.WriteLine(SizeOf<double>()); // 8
// SizeOf<string>(); // コンパイルエラー: string は参照型

// 気温データを表す値型: ソートと等値比較を実装
public readonly struct Temperature
    : IComparable<Temperature>, IEquatable<Temperature>
{
    public double Celsius { get; }

    public Temperature(double celsius) => Celsius = celsius;

    // IComparable<T>: ソート・Max/Min の基礎
    // 戻り値: 負 = this < other, 0 = 等しい, 正 = this > other
    public int CompareTo(Temperature other)
        => Celsius.CompareTo(other.Celsius);

    // IEquatable<T>: == / Equals での比較（object.Equals より効率的）
    public bool Equals(Temperature other)
        => Celsius == other.Celsius;

    // object.Equals のオーバーライドも必ず合わせる
    public override bool Equals(object? obj)
        => obj is Temperature other && Equals(other);

    // GetHashCode も合わせてオーバーライド（辞書・セットで正しく動作させるため）
    public override int GetHashCode() => Celsius.GetHashCode();

    public static bool operator ==(Temperature a, Temperature b) => a.Equals(b);
    public static bool operator !=(Temperature a, Temperature b) => !a.Equals(b);
    public static bool operator < (Temperature a, Temperature b) => a.CompareTo(b) < 0;
    public static bool operator > (Temperature a, Temperature b) => a.CompareTo(b) > 0;

    public override string ToString() => $"{Celsius}°C";
}

// 使い方: List<T>.Sort() / Max / Min がそのまま使える
var temps = new List<Temperature>
{
    new(36.5), new(38.2), new(35.1), new(37.0)
};

temps.Sort();   // IComparable<T> を使って昇順ソート
Console.WriteLine(temps[0]);   // 35.1°C（最小値）
Console.WriteLine(temps.Max()); // 38.2°C（LINQ の Max も使える）

// HashSet / Dictionary でも正しく動作（Equals + GetHashCode が必要）
var set = new HashSet<Temperature> { new(36.5), new(36.5), new(37.0) };
Console.WriteLine(set.Count);  // 2（重複が除去される）

// default(T) の値
Console.WriteLine(default(int));     // 0
Console.WriteLine(default(bool));    // False
Console.WriteLine(default(double));  // 0
Console.WriteLine(default(string));  // （null: 空文字列ではない）
Console.WriteLine(default(DateTime)); // 0001/01/01 00:00:00

// ジェネリックコードでの使い方
static T GetValueOrDefault<T>(T? value) where T : struct
    => value ?? default;   // value が null の場合 default(T) を返す

Console.WriteLine(GetValueOrDefault<int>(null));    // 0
Console.WriteLine(GetValueOrDefault<double>(3.14)); // 3.14

// 参照型の default は null
static T? FirstOrDefault<T>(IEnumerable<T> source, T? fallback = default)
{
    foreach (var item in source) return item;
    return fallback;  // default は null（参照型）または ゼロ系（値型）
}

// キャッシュパターンでの活用
public class LazyCache<T> where T : class
{
    private T? _cache = default;   // null（参照型）

    public T Get(Func<T> factory)
        => _cache ??= factory();   // null なら factory を呼ぶ
}

// C# 7.1+ では型を省略して default だけでも使える
int  x = default;      // 0
bool b = default;      // false
string? s = default;   // null

// 動物クラス階層
class Animal { public virtual string Name => "Animal"; }
class Dog    : Animal { public override string Name => "Dog"; }
class Cat    : Animal { public override string Name => "Cat"; }

// NG: List<Dog> は List<Animal> に代入できない
// List<Dog>    dogs    = new List<Dog> { new Dog() };
// List<Animal> animals = dogs;   // コンパイルエラー!
// → animals.Add(new Cat()); が可能になってしまい、Dog リストに Cat が混入する危険

// OK: IEnumerable<T> は out T（共変）なので安全
IEnumerable<Dog>    dogs    = new List<Dog> { new Dog(), new Dog() };
IEnumerable<Animal> animals = dogs;   // OK! IEnumerable<Dog> → IEnumerable<Animal>
// → IEnumerable<T> は読み取り専用なので Cat を追加する危険がない

foreach (Animal a in animals)
    Console.WriteLine(a.Name);  // Dog, Dog

// IReadOnlyList<T> も out T（共変）
IReadOnlyList<Dog>    dogList    = new List<Dog> { new Dog() };
IReadOnlyList<Animal> animalList = dogList;  // OK

// IReadOnlyCollection<T> も共変
IReadOnlyCollection<Dog>    dogCol    = new List<Dog> { new Dog() };
IReadOnlyCollection<Animal> animalCol = dogCol;  // OK

// Action<T>: in T（反変）の例
Action<Animal> printAnimal = a => Console.WriteLine(a.Name);

// Action<Animal> を Action<Dog> に代入できる（反変）
Action<Dog> printDog = printAnimal;  // OK!
// → Action<Animal> は Animal を受け取れる → Dog（Animal の派生）も受け取れる

printDog(new Dog());   // Dog（Animal として扱われる）

// IComparer<T>: in T（反変）の例
IComparer<Animal> animalComparer = Comparer<Animal>.Default;
IComparer<Dog>    dogComparer    = animalComparer;  // OK（反変）

// Func<TIn, TOut>: TIn が反変（in）、TOut が共変（out）
Func<Animal, string> getName    = a => a.Name;
Func<Dog, string>    getDogName = getName;  // OK（引数: 反変、戻り値: 共変）

string name = getDogName(new Dog());
Console.WriteLine(name);  // Dog

// out T: 共変インターフェース（T を返すのみ）
interface IProducer<out T>
{
    T Produce();          // OK: T を返す（生産者）
    // void Consume(T item); // NG: out T のインターフェースで T を受け取ると違反
}

// in T: 反変インターフェース（T を受け取るのみ）
interface IConsumer<in T>
{
    void Consume(T item); // OK: T を受け取る（消費者）
    // T Produce();       // NG: in T のインターフェースで T を返すと違反
}

// IProducer<out T> は共変なので派生型 → 基底型への代入が可能
class AnimalProducer : IProducer<Animal>
{
    public Animal Produce() => new Animal();
}

IProducer<Animal> animalProducer = new AnimalProducer();
IProducer<object> objProducer    = animalProducer;  // OK（out T = 共変）

// 型別インスタンス数をカウントするジェネリッククラス
public class InstanceCounter<T>
{
    // _count は InstanceCounter<int> と InstanceCounter<string> で独立している
    private static int _count = 0;

    public InstanceCounter() => Interlocked.Increment(ref _count);

    public static int Count => _count;
}

var i1 = new InstanceCounter<int>();
var i2 = new InstanceCounter<int>();
var s1 = new InstanceCounter<string>();

Console.WriteLine(InstanceCounter<int>.Count);    // 2 (int 用の _count)
Console.WriteLine(InstanceCounter<string>.Count); // 1 (string 用の _count)

// 応用: 型別キャッシュ（型安全なグローバルキャッシュ）
public static class TypeCache<T>
{
    // T ごとに独立したキャッシュ辞書
    private static readonly Dictionary<string, T> _cache = new();

    public static void Set(string key, T value) => _cache[key] = value;
    public static T?   Get(string key) => _cache.TryGetValue(key, out var v) ? v : default;
    public static int  Size            => _cache.Count;
}

TypeCache<int>.Set("age", 30);
TypeCache<string>.Set("name", "Alice");

Console.WriteLine(TypeCache<int>.Get("age"));       // 30
Console.WriteLine(TypeCache<string>.Get("name"));   // Alice
Console.WriteLine(TypeCache<int>.Size);             // 1
Console.WriteLine(TypeCache<string>.Size);          // 1（別キャッシュ）

// 基底クラス
public class Repository<T> where T : class
{
    protected readonly List<T> _items = new();

    public virtual void Add(T item) => _items.Add(item);
    public virtual IReadOnlyList<T> GetAll() => _items;
}

// パターン①: 型パラメーターをそのまま引き継ぐ
public class AuditRepository<T> : Repository<T> where T : class
{
    private readonly List<string> _log = new();

    public override void Add(T item)
    {
        _log.Add($"{DateTime.Now}: Added {typeof(T).Name}");
        base.Add(item);
    }

    public IReadOnlyList<string> GetLog() => _log;
}

// パターン②: 型引数を具体的な型に固定する
public class User { public string Name { get; init; } = ""; }

public class UserRepository : Repository<User>   // T = User に固定
{
    public User? FindByName(string name)
        => _items.FirstOrDefault(u => u.Name == name);
}

// 使い方
var auditRepo = new AuditRepository<User>();
auditRepo.Add(new User { Name = "Alice" });
auditRepo.Add(new User { Name = "Bob" });
Console.WriteLine(auditRepo.GetLog()[0]);  // ...: Added User

var userRepo = new UserRepository();
userRepo.Add(new User { Name = "Charlie" });
Console.WriteLine(userRepo.FindByName("Charlie")?.Name); // Charlie

// IComparable<T> 制約: T の大小比較が必要
public class MinStack<T> where T : IComparable<T>
{
    // 通常スタック + 最小値履歴スタックの2本構成
    private readonly Stack<T> _data    = new();
    private readonly Stack<T> _minData = new();

    public int  Count   => _data.Count;
    public bool IsEmpty => _data.Count == 0;

    public void Push(T item)
    {
        _data.Push(item);
        // 最小値スタックは「現在の最小値以下」のときだけ積む
        if (_minData.Count == 0 || item.CompareTo(_minData.Peek()) <= 0)
            _minData.Push(item);
    }

    public T Pop()
    {
        if (IsEmpty) throw new InvalidOperationException("スタックが空です");
        var top = _data.Pop();
        if (top.CompareTo(_minData.Peek()) == 0)
            _minData.Pop();
        return top;
    }

    public T Peek() => IsEmpty
        ? throw new InvalidOperationException("スタックが空です")
        : _data.Peek();

    // O(1) で現在の最小値を取得
    public T Min() => _minData.Count == 0
        ? throw new InvalidOperationException("スタックが空です")
        : _minData.Peek();
}

// 使い方
var stack = new MinStack<int>();
stack.Push(3);
stack.Push(1);
stack.Push(4);
stack.Push(1);
stack.Push(5);

Console.WriteLine(stack.Min());  // 1（O(1)）
stack.Pop();  // 5
stack.Pop();  // 1（上の 1）
Console.WriteLine(stack.Min());  // 1（まだ残っている）
stack.Pop();  // 4
Console.WriteLine(stack.Min());  // 1

// string でも動作する（IComparable<string> 実装済み）
var strStack = new MinStack<string>();
strStack.Push("banana");
strStack.Push("apple");
strStack.Push("cherry");
Console.WriteLine(strStack.Min());  // apple（辞書順最小）

// 非ジェネリック: object に統一 → 値型はボクシング発生
static object BoxedMax(object a, object b)
    => ((IComparable)a).CompareTo(b) >= 0 ? a : b;

// ジェネリック: 値型用に JIT が特殊化されたコードを生成（ボクシングなし）
static T GenericMax<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) >= 0 ? a : b;

// GenericMax<int>: JIT が int 専用のネイティブコードを生成
// → int は値型なのでスタック上で計算、ヒープ確保ゼロ
int result = GenericMax(100_000, 200_000);

// BoxedMax: 引数をヒープにボクシング → 比較 → アンボクシング
object boxed = BoxedMax(100_000, 200_000);  // ボクシング 2回発生

// CLR の型特殊化ルール:
// ・値型（int, double, struct等）ごとに別々のネイティブコードが生成される
//   → List<int> と List<double> は完全に別のコードを持つ
// ・参照型はすべて同じネイティブコードを共有する（ポインタサイズが同じため）
//   → List<string> と List<object> は同じコードを使いまわす

// List<T> の格納はボクシングなし
var ints = new List<int>(1_000_000);
for (int i = 0; i < 1_000_000; i++)
    ints.Add(i);   // ボクシングなし: int はそのまま内部配列に格納される

// ArrayList の場合: 全要素をボクシングするため遅く、メモリを多く使う
var boxedList = new System.Collections.ArrayList();
for (int i = 0; i < 1_000_000; i++)
    boxedList.Add(i);   // ボクシング 100万回発生