【C#】シングルトン完全ガイド｜6実装パターン比較・Lazy・beforefieldinit・DI・アンチパターンまで

public sealed class EagerSingleton
{
    // 静的フィールドの初期化は CLR が1度だけ・スレッドセーフに実行する
    private static readonly EagerSingleton _instance = new();

    // コンストラクタを private にして外部からの new を禁止
    private EagerSingleton() { }

    public static EagerSingleton Instance => _instance;

    public void DoSomething() => Console.WriteLine("実行");
}

// 使用
EagerSingleton.Instance.DoSomething();

// ① 静的フィールド初期化子のみ → beforefieldinit フラグが立つ
public sealed class A
{
    // JIT はこのフィールドを「必要になった時、初めて参照する前までに」初期化する
    // 正確なタイミングは保証されない（型参照の前に生成される可能性もある）
    public static readonly A Instance = new();
    private A() => Console.WriteLine("A created");
}

// ② 静的コンストラクタを明示 → beforefieldinit が立たない
public sealed class B
{
    public static readonly B Instance;
    static B()   // 静的コンストラクタ
    {
        Instance = new B();
        Console.WriteLine("B created");
    }
    private B() { }
}

// 両者の違い: 「他のメソッドを先に呼んでも B は初期化まで待たされる」という厳密性
public static class Caller
{
    public static void Log()
    {
        Console.WriteLine("Log called");
        // ここで B.Instance を参照する直前に B が初期化される
        Console.WriteLine(B.Instance);
    }
}

public sealed class AppConfig
{
    private static readonly Lazy<AppConfig> _instance = new(() => LoadFromFile());

    public static AppConfig Instance => _instance.Value;

    private AppConfig(string key) => ApiKey = key;
    public string ApiKey { get; }

    private static AppConfig LoadFromFile()
    {
        // 時間のかかる初期化。初回 .Value アクセスで1度だけ実行される
        var key = File.ReadAllText("apikey.txt").Trim();
        return new AppConfig(key);
    }
}

// 初回アクセスで初期化される
Console.WriteLine(AppConfig.Instance.ApiKey);

// Lazy<T> のコンストラクタで LazyThreadSafetyMode を指定できる

// ① ExecutionAndPublication（デフォルト）
//    初期化は1スレッドだけが実行し、他は待機する。最も安全
var safe = new Lazy<Foo>(() => new Foo(), LazyThreadSafetyMode.ExecutionAndPublication);

// ② PublicationOnly
//    複数スレッドが同時に初期化関数を呼ぶ可能性あり、先に完了したものの結果が採用される
//    → 関数が副作用なし・安価ならこちら（競争しても無駄になるだけ）
var pub = new Lazy<Foo>(() => new Foo(), LazyThreadSafetyMode.PublicationOnly);

// ③ None
//    スレッドセーフ性を捨てる。単一スレッドからしか参照しない前提
var none = new Lazy<Foo>(() => new Foo(), LazyThreadSafetyMode.None);

public sealed class DclSingleton
{
    private static volatile DclSingleton? _instance; // volatile が必須
    private static readonly object _lock = new();

    private DclSingleton() { }

    public static DclSingleton Instance
    {
        get
        {
            if (_instance is null)                  // 1回目のチェック（ロックなし・速い）
            {
                lock (_lock)
                {
                    if (_instance is null)          // 2回目のチェック（ロック内）
                        _instance = new DclSingleton();
                }
            }
            return _instance;
        }
    }
}

public sealed class NestedSingleton
{
    private NestedSingleton() { }

    public static NestedSingleton Instance => Holder.Value;

    // 内部クラスは「外側のクラスの他のメンバが参照された」時点では初期化されない
    // → Instance プロパティが呼ばれた瞬間に Holder が初めて参照され初期化が走る
    private static class Holder
    {
        internal static readonly NestedSingleton Value = new();

        // static コンストラクタを書くと beforefieldinit が外れてさらに厳密に
        static Holder() { }
    }
}

// ASP.NET Core / Worker Service / Console 全てで使える
var builder = Host.CreateApplicationBuilder(args);
builder.Services.AddSingleton<IApiClient, ApiClient>();
builder.Services.AddSingleton<MetricsCollector>();

var app = builder.Build();

// インターフェース経由で使うのでテスト時に差し替え可能
public class OrderService(IApiClient api)
{
    public Task ProcessAsync(Order o) => api.SendAsync(o);
}

// テスト: Fake/Mock を注入
[Fact]
public async Task Test_Process()
{
    var fake = new FakeApiClient();
    var svc  = new OrderService(fake);
    await svc.ProcessAsync(new Order());
    Assert.Equal(1, fake.SendCount);
}

// シングルトンが IDisposable なら、アプリ終了時に Dispose を呼ぶ必要がある
public sealed class DbConnectionPool : IDisposable
{
    private static readonly Lazy<DbConnectionPool> _instance = new(() => new());
    public static DbConnectionPool Instance => _instance.Value;

    private readonly SemaphoreSlim _lock = new(1, 1);
    private DbConnectionPool() { }

    public void Dispose()
    {
        _lock.Dispose();
        // 管理している全コネクションもクローズ
    }
}

// 手書きシングルトンの場合: AppDomain.CurrentDomain.ProcessExit などで呼ぶ
AppDomain.CurrentDomain.ProcessExit += (_, _) =>
{
    if (DbConnectionPool.Instance is IDisposable d) d.Dispose();
};

// DI シングルトンなら Host の停止時に自動 Dispose される
// builder.Services.AddSingleton<DbConnectionPool>();
// → app.StopAsync() や using var host で自動

// シングルトンのつもりでも…
var type = typeof(EagerSingleton);
var ctor = type.GetConstructor(
    BindingFlags.Instance | BindingFlags.NonPublic,
    binder: null, types: Type.EmptyTypes, modifiers: null);

var another = (EagerSingleton)ctor!.Invoke(null);
// ↑ 2つ目のインスタンスが作られてしまう

// 対策: コンストラクタ内で「2回目以降は例外」とガード
public sealed class GuardedSingleton
{
    private static readonly GuardedSingleton _instance = new();
    private static int _ctorCount;

    public static GuardedSingleton Instance => _instance;

    private GuardedSingleton()
    {
        if (Interlocked.Increment(ref _ctorCount) > 1)
            throw new InvalidOperationException("Singleton を2回目の生成しようとした");
    }
}

// ただし「リフレクションで壊される可能性」を気にするより、
// 最初から DI 経由で使う・sealed にする・Enum-based Singleton にする方が現実的

// ① 完全にステートレスな関数群なら → static class
public static class StringHelper
{
    public static string Truncate(string s, int max)
        => s.Length <= max ? s : s[..max] + "...";
}

// ② 状態を持つが差し替える可能性がない・内部利用のみ → Lazy<T> シングルトン
public sealed class LogBuffer
{
    private static readonly Lazy<LogBuffer> _instance = new(() => new());
    public static LogBuffer Instance => _instance.Value;
    private readonly ConcurrentQueue<string> _buffer = new();
    private LogBuffer() { }
    public void Add(string s) => _buffer.Enqueue(s);
}

// ③ 状態を持ち、テストで差し替える可能性がある → インターフェース + DI シングルトン
public interface IMetricsCollector
{
    void Increment(string name);
}

public sealed class MetricsCollector : IMetricsCollector
{
    private readonly ConcurrentDictionary<string, long> _counters = new();
    public void Increment(string name) =>
        _counters.AddOrUpdate(name, 1, (_, v) => v + 1);
}

// 登録: builder.Services.AddSingleton<IMetricsCollector, MetricsCollector>();

// NG: シングルトンを「どこからでも書き換えられる共有変数」として使う
public sealed class GlobalState
{
    public static GlobalState Instance { get; } = new();
    public string CurrentUser { get; set; } = "";   // 誰でも書き換えられる
    public int RequestCount  { get; set; }           // レース条件あり
}

// Controller からも Service からも Repository からも書き換え可能
// → デバッグ困難・競合状態・テスト不能

// OK: 不変データ + スレッドセーフな状態管理
public sealed class AppMetrics
{
    private long _requestCount;
    public long RequestCount => Interlocked.Read(ref _requestCount);
    public void IncrementRequest() => Interlocked.Increment(ref _requestCount);
}

// NG: シングルトン内から別サービスを直接引いて依存を隠す
public sealed class OrderService
{
    public static OrderService Instance { get; } = new();

    public void Process(Order o)
    {
        // 依存関係が見えない・テスト時に差し替え不可
        Logger.Instance.Log("start");
        Database.Instance.Save(o);
        Notifier.Instance.Send(o.UserId, "完了");
    }
}

// OK: 依存をコンストラクタで受け取る（DI）
public sealed class OrderService2(ILogger logger, IDatabase db, INotifier notifier)
{
    public void Process(Order o)
    {
        logger.Log("start");
        db.Save(o);
        notifier.Send(o.UserId, "完了");
    }
}

// NG: 継承でシングルトン機能を提供しようとする
public abstract class SingletonBase<T> where T : SingletonBase<T>, new()
{
    private static readonly Lazy<T> _instance = new(() => new T());
    public static T Instance => _instance.Value;
}

public sealed class MyService : SingletonBase<MyService> { }

// 問題:
//  - new() 制約で private コンストラクタが書けない（public になり保証が弱まる）
//  - 継承できない型（record / struct / sealed）に使えない
//  - OOP の単一継承を無駄に消費する

// OK: 型ごとに Lazy<T> を直接書く（わずか3行）
public sealed class MyService
{
    private static readonly Lazy<MyService> _instance = new(() => new MyService());
    public static MyService Instance => _instance.Value;
    private MyService() { }
}