Singleton Pattern Gerçek Kullanımı ve Entegrasyon

Giriş

Singleton Pattern, bir sınıfın tek bir instance’ının oluşturulmasını ve bu instance’a global erişim sağlanmasını garanti eden yapıdır. Büyük ölçekli uygulamalarda, örneğin loglama, cache yönetimi veya configuration gibi durumlarda sıklıkla tercih edilir.
Bu yazıda:

1. Singleton Pattern nedir?
2. Kurulum ve temel örnek
3. Katmanlı mimaride uygulanışı
4. Performans ve thread-safety
5. Gerçek projelerden örnekler

1. Singleton Pattern Nedir?

• Amaç: Sınıftan yalnızca bir nesne oluşturulmasını sağlamak.
• Kullanım Alanları: LogManager, Cache, ConfigurationProvider vb.
• Yarar: Tekilleştirilmiş kaynak kullanımı, global state yönetimi.

2. Kurulum ve Temel Örnek

public class Singleton
{
    private static Singleton _instance;
    private static readonly object _lock = new object();

    // Özel constructor
    private Singleton() { }

    public static Singleton GetInstance()
    {
        if (_instance == null)
        {
            lock (_lock)
            {
                if (_instance == null)
                    _instance = new Singleton();
            }
        }
        return _instance;
    }
}

• Double-check locking ile thread-safe singleton örneği.
• İlk erişimde örnek oluşturulur; sonraki çağrılarda aynı nesne döner.

3. Katmanlı Mimari Entegrasyonu

• Infrastructure Layer: Singleton örnekleri burada tutulur (örn. CacheManager).
• Application Layer: GetInstance ile erişim sağlanır.
• Presentation/API Layer: Servis veya controller’lar singleton instance’ı kullanır.

4. Performans ve Thread Safety

1. Lazy Initialization: İlk erişim zamanına kadar örnek oluşturulmaz.
2. Lock Maliyeti: lock bloğu sadece ilk oluşturma sırasında; sonrasında if kontrolü hızlı.
3. .NET Lazy<T> Kullanımı:

public class Singleton
{
    private static readonly Lazy<Singleton> _lazy =
        new Lazy<Singleton>(() => new Singleton());

    private Singleton() { }

    public static Singleton Instance => _lazy.Value;
}

• Avantaj: lock ihtiyacı ortadan kalkar, kod daha okunabilir.

5. Gerçek Projelerden Örnekler

• Cache Manager:

public class CacheManager
{
    private static readonly Lazy<MemoryCache> _cache =
        new Lazy<MemoryCache>(() => new MemoryCache(new MemoryCacheOptions()));

    public static MemoryCache Instance => _cache.Value;
}

• Configuration Provider:

public class ConfigurationProvider
{
    private IConfiguration _config;
    private static readonly Lazy<ConfigurationProvider> _instance =
        new Lazy<ConfigurationProvider>(() =>
        {
            var builder = new ConfigurationBuilder().AddJsonFile("appsettings.json");
            return new ConfigurationProvider { _config = builder.Build() };
        });

    private ConfigurationProvider() { }

    public static ConfigurationProvider Instance => _instance.Value;

    public string GetValue(string key) => _config[key];
}

İleri Okuma ve Kaynaklar

• Singleton Pattern – Refactoring Guru
• Lazy<T> vs Double-Check Locking

6. Sonuç

• Singleton Pattern, global state ve tekil kaynaklar için ideal.
• Doğru thread-safety ve lazy initialization teknikleri ile performans garantisi sağlar.
• Katmanlı yapılarda Infrastructure katmanına koyarak, business kodunu temiz tutar.