[C#] Mutable vs Immutable — オブジェクトを「変えられる」設計と「変えられない」設計

public class MutablePoint
{
    public int X { get; set; }
    public int Y { get; set; }
}

var p = new MutablePoint { X = 10, Y = 20 };
p.X = 30; // 状態を変更できる

public class ImmutablePoint
{
    public int X { get; }
    public int Y { get; }

    public ImmutablePoint(int x, int y) { X = x; Y = y; }
}

var p = new ImmutablePoint(10, 20);
// p.X = 30; // コンパイルエラー
var moved = new ImmutablePoint(30, p.Y); // 新しいインスタンスを作る

account.Balance -= 1000; // 引き出し

// Mutable: 既存のバッファに追記（効率的）
var sb = new StringBuilder();
for (int i = 0; i < 10000; i++)
    sb.Append(i);

// Immutable: 毎回新しい string を生成（非効率）
var s = "";
for (int i = 0; i < 10000; i++)
    s += i; // 毎回新しい string が作られ、古い string は GC 対象に

// Entity Framework のエンティティ（従来のスタイル）
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal Price { get; set; }
}

public class MutableConfig
{
    public int Timeout { get; set; } = 30;
}

// 共有された設定オブジェクト
var config = new MutableConfig();
ServiceA.Initialize(config);
ServiceB.Initialize(config);

// ServiceA が勝手にタイムアウトを変更
config.Timeout = 5;

// ServiceB は自分が受け取った config の Timeout が
// いつの間にか 5 に変わっていることに気づかない

public class ImmutableConfig
{
    public int Timeout { get; init; } = 30;
}

var config = new ImmutableConfig();
// config.Timeout = 5; // コンパイルエラー — 変更できない

// 変更が必要なら新しいインスタンスを作る（元のオブジェクトは影響を受けない）
var customConfig = new ImmutableConfig { Timeout = 5 };

// Mutable — ロックが必要
public class MutableCounter
{
    private int _count;
    private readonly object _lock = new();

    public void Increment()
    {
        lock (_lock) { _count++; }
    }

    public int Count
    {
        get { lock (_lock) { return _count; } }
    }
}

// Immutable — スレッドセーフが保証される
public record Snapshot(int Count, DateTime Timestamp);

// どのスレッドから読んでも安全
Snapshot current = new(0, DateTime.UtcNow);

// 更新は「新しいスナップショットへの参照の差し替え」で行う
Interlocked.Exchange(ref current, new Snapshot(1, DateTime.UtcNow));

public class MutableKey
{
    public int Value { get; set; }

    public override int GetHashCode() => Value;
    public override bool Equals(object? obj) => obj is MutableKey k && k.Value == Value;
}

var set = new HashSet<MutableKey>();
var key = new MutableKey { Value = 1 };
set.Add(key);

Console.WriteLine(set.Contains(key)); // True

key.Value = 2; // ハッシュコードが変わる

Console.WriteLine(set.Contains(key)); // False — もう見つからない

// Immutable なテストデータ — 他のテストから影響を受けない
var order = new Order("ORD-001", DateTime.UtcNow, 1500m);
Assert.Equal("ORD-001", order.Id);
// order の状態は変わりようがないので、後続のテストにも影響しない

// Mutable DTO（従来のスタイル）
public class UserResponse
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public string Email { get; set; } = "";
}

// Immutable DTO（推奨）
public record UserResponse(int Id, string Name, string Email);

// Mutable な設定（危険）
public class AppSettings
{
    public string ConnectionString { get; set; } = "";
    public int MaxRetry { get; set; } = 3;
}

// どこかのコードが勝手に変更できてしまう
settings.MaxRetry = 0; // リトライしなくなる

// Immutable な設定（安全）
public class AppSettings
{
    public required string ConnectionString { get; init; }
    public int MaxRetry { get; init; } = 3;
}

// 初期化後は変更不可
var settings = new AppSettings { ConnectionString = "Server=..." };
// settings.MaxRetry = 0; // コンパイルエラー

public class Character
{
    public string Name { get; init; }
    public int Hp { get; set; }
    public int Mp { get; set; }
    public float X { get; set; }
    public float Y { get; set; }

    public Character(string name, int hp, int mp)
    {
        Name = name;
        Hp = hp;
        Mp = mp;
    }

    public void TakeDamage(int damage) => Hp = Math.Max(0, Hp - damage);
    public void MoveTo(float x, float y) { X = x; Y = y; }
}

// 外部に公開するスナップショットは Immutable
public record CharacterSnapshot(string Name, int Hp, int Mp, float X, float Y);

public class Character
{
    // ... Mutable な内部状態 ...

    public CharacterSnapshot ToSnapshot() => new(Name, Hp, Mp, X, Y);
}

// イベントは Immutable
public abstract record OrderEvent(string OrderId, DateTime OccurredAt);
public record OrderPlaced(string OrderId, DateTime OccurredAt, string CustomerId) 
    : OrderEvent(OrderId, OccurredAt);
public record OrderShipped(string OrderId, DateTime OccurredAt, string TrackingNumber) 
    : OrderEvent(OrderId, OccurredAt);
public record OrderCancelled(string OrderId, DateTime OccurredAt, string Reason) 
    : OrderEvent(OrderId, OccurredAt);

// イベントを再生して現在の状態を構築
public static OrderStatus Replay(IEnumerable<OrderEvent> events)
{
    var status = OrderStatus.Unknown;
    foreach (var e in events)
    {
        status = e switch
        {
            OrderPlaced   => OrderStatus.Placed,
            OrderShipped  => OrderStatus.Shipped,
            OrderCancelled => OrderStatus.Cancelled,
            _ => status
        };
    }
    return status;
}

// C# 11 で実現する「必須かつ不変」なデータモデル
public record User
{
    public required string Id { get; init; }
    public required string Name { get; init; }
    public required string Email { get; init; }
}

var alice = new User { Id = "1", Name = "Alice", Email = "alice@example.com" };
var updated = alice with { Email = "new@example.com" }; // 元のオブジェクトは不変