1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// In .NET Core / .NET 5+
public void ConfigureServices(IServiceCollection services)
{
    // Type-based singleton registration
    services.AddSingleton<IConfigurationService, ConfigurationService>();
    
    // Register existing instance as singleton
    var settings = new AppSettings { MaxRetries = 3, Timeout = 30 };
    services.AddSingleton(settings);
    
    // Interface pointing to existing instance
    services.AddSingleton<IAppSettings>(settings);
    
    // Factory-based singleton with lazy initialization
    services.AddSingleton<IExpensiveService>(provider =>
    {
        var config = provider.GetRequiredService<IConfiguration>();
        var logger = provider.GetRequiredService<ILogger<ExpensiveService>>();
        
        // This factory runs only once, on first resolution
        logger.LogInformation("Initializing ExpensiveService...");
        return new ExpensiveService(config["ServiceEndpoint"]);
    });
    
    // HttpClient factory (recommended pattern for HTTP)
    services.AddHttpClient<IApiClient, ApiClient>(client =>
    {
        client.BaseAddress = new Uri("https://api.example.com/");
        client.Timeout = TimeSpan.FromSeconds(30);
    });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// In Spring, singleton is the DEFAULT scope
@Configuration
public class AppConfig {
    
    // Singleton by default - no annotation needed
    @Bean
    public ConfigurationService configurationService() {
        return new ConfigurationService();
    }
    
    // Explicit singleton annotation (same as default)
    @Bean
    @Scope("singleton")
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager();
    }
}
 
// Component scanning also creates singletons by default
@Service  // Implicitly singleton
public class OrderProcessingService {
    private final PaymentGateway paymentGateway;
    
    @Autowired
    public OrderProcessingService(PaymentGateway paymentGateway) {
        this.paymentGateway = paymentGateway;
        System.out.println("OrderProcessingService singleton created");
    }
}
 
// This class must be thread-safe!
// All controller requests share the same instance

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// In InversifyJS - explicit singleton binding
import { Container } from "inversify";
 
const container = new Container();
 
// Singleton scope - one instance for container lifetime
container.bind<IConfigService>(TYPES.ConfigService)
    .to(ConfigService)
    .inSingletonScope();
 
// Verify singleton behavior
const config1 = container.get<IConfigService>(TYPES.ConfigService);
const config2 = container.get<IConfigService>(TYPES.ConfigService);
console.log(config1 === config2); // true - same instance
 
// In NestJS - DEFAULT scope is singleton
@Injectable() // Scope.DEFAULT = singleton
export class ConfigService {
    private readonly settings: Map<string, string>;
    
    constructor() {
        console.log('ConfigService singleton created');
        this.settings = new Map();
        this.loadSettings();
    }
    
    get(key: string): string | undefined {
        return this.settings.get(key);
    }
    
    private loadSettings(): void {
        // Load from environment, files, etc.
        this.settings.set('API_URL', process.env.API_URL || '');
    }
}
 
// Explicit singleton for emphasis
@Injectable({ scope: Scope.DEFAULT })
export class CacheService {
    private readonly cache = new Map<string, CacheEntry>();
    // Implementation...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// ✅ SAFE: Completely stateless singleton
public class PasswordHasher : IPasswordHasher
{
    // No instance state at all
    public string Hash(string password)
    {
        using var sha = SHA256.Create();
        var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(password));
        return Convert.ToBase64String(bytes);
    }
    
    public bool Verify(string password, string hash)
    {
        return Hash(password) == hash;
    }
}
 
// ✅ SAFE: Immutable state only
public class ConfigurationService : IConfigurationService
{
    // Readonly field, set once at construction
    private readonly ImmutableDictionary<string, string> _settings;
    
    public ConfigurationService(IConfiguration config)
    {
        _settings = config.AsEnumerable()
            .Where(kvp => kvp.Value != null)
            .ToImmutableDictionary(kvp => kvp.Key, kvp => kvp.Value!);
    }
    
    public string GetSetting(string key) => 
        _settings.TryGetValue(key, out var value) ? value : string.Empty;
}
 
// ✅ SAFE: Thread-safe collection
public class InMemoryCache : ICache
{
    // ConcurrentDictionary handles thread safety internally
    private readonly ConcurrentDictionary<string, CacheEntry> _cache = new();
    
    public void Set(string key, object value, TimeSpan expiry)
    {
        _cache[key] = new CacheEntry(value, DateTime.UtcNow.Add(expiry));
    }
    
    public T? Get<T>(string key)
    {
        if (_cache.TryGetValue(key, out var entry) && entry.ExpiresAt > DateTime.UtcNow)
        {
            return (T)entry.Value;
        }
        return default;
    }
}
 
// ❌ BROKEN: Unprotected mutable state
public class BrokenCounterService : ICounterService
{
    private int _count = 0; // ⚠️ RACE CONDITION!
    
    public int Increment()
    {
        _count++;  // NOT ATOMIC! Read-modify-write = race condition
        return _count;
    }
    
    // With 1000 concurrent calls, final count might be 950, 980, or 1000
    // depending on thread timing - data corruption
}
 
// ✅ SAFE: Atomic operations
public class SafeCounterService : ICounterService
{
    private int _count = 0;
    
    public int Increment()
    {
        return Interlocked.Increment(ref _count); // Atomic increment
    }
}
 
// ❌ BROKEN: Regular Dictionary (not thread-safe)
public class BrokenCacheService : ICache
{
    private readonly Dictionary<string, object> _cache = new(); // ⚠️
    
    public void Set(string key, object value)
    {
        _cache[key] = value; // Concurrent writes can corrupt internal state
    }
    
    // Runtime: Dictionary throws, loops forever, or returns garbage
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

// Default: Lazy initialization
services.AddSingleton<IMyService, MyService>();
// MyService created when first injected or resolved
 
// Force eager initialization: Resolve at startup
public void Configure(IApplicationBuilder app, IServiceProvider services)
{
    // Force immediate creation by resolving at startup
    var myService = services.GetRequiredService<IMyService>();
    
    // Or use a dedicated method if you have many
    EagerlyInitializeSingletons(services);
}
 
private void EagerlyInitializeSingletons(IServiceProvider services)
{
    // These are all created NOW, before first request
    services.GetRequiredService<ICacheWarmer>();
    services.GetRequiredService<IFeatureFlagService>();
    services.GetRequiredService<IMetricsCollector>();
}
 
// Pattern: Self-initializing singleton with fail-fast
public class FeatureFlagService : IFeatureFlagService
{
    private readonly ImmutableDictionary<string, bool> _flags;
    
    public FeatureFlagService(IConfiguration config, ILogger<FeatureFlagService> logger)
    {
        logger.LogInformation("Loading feature flags...");
        
        try
        {
            // If this fails, we want to know at startup, not on first use
            _flags = LoadFlagsFromRemoteService(config["FeatureService:Url"]);
            logger.LogInformation("Loaded {Count} feature flags", _flags.Count);
        }
        catch (Exception ex)
        {
            // Fail fast: application should not start with broken features
            logger.LogCritical(ex, "Failed to load feature flags");
            throw;
        }
    }
}
 
// In Spring: Eager initialization is default for singletons
@Component
public class StartupService implements InitializingBean {
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // Called at startup, not lazily
        System.out.println("StartupService initialized");
    }
}
 
// Explicit lazy in Spring
@Component
@Lazy
public class LazyService {
    // Created only when first injected
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

// ✅ Configuration Service: Immutable after construction
public class AppConfiguration : IAppConfiguration
{
    public string DatabaseConnection { get; }
    public string ApiKey { get; }
    public int MaxRetryAttempts { get; }
    public TimeSpan RequestTimeout { get; }
    
    public AppConfiguration(IConfiguration config)
    {
        // Read at construction, immutable thereafter
        DatabaseConnection = config.GetConnectionString("Default") 
            ?? throw new InvalidOperationException("Missing connection string");
        ApiKey = config["ExternalApi:Key"] 
            ?? throw new InvalidOperationException("Missing API key");
        MaxRetryAttempts = config.GetValue<int>("Resilience:MaxRetries", 3);
        RequestTimeout = config.GetValue<TimeSpan>("Resilience:Timeout", 
            TimeSpan.FromSeconds(30));
    }
}
 
// ✅ In-Memory Cache: Thread-safe with concurrent collections
public class ProductCache : IProductCache
{
    private readonly ConcurrentDictionary<int, Product> _cache = new();
    private readonly IProductRepository _repository;
    
    public ProductCache(IProductRepository repository)
    {
        _repository = repository;
    }
    
    public async Task<Product> GetOrLoadAsync(int productId)
    {
        // GetOrAdd is atomic - prevents duplicate loading
        if (_cache.TryGetValue(productId, out var cached))
        {
            return cached;
        }
        
        // Load from database (only one thread will do this per key)
        var product = await _repository.GetByIdAsync(productId);
        _cache.TryAdd(productId, product);
        return product;
    }
    
    public void InvalidateProduct(int productId)
    {
        _cache.TryRemove(productId, out _);
    }
}
 
// ✅ Metrics Collector: Atomic operations for counters
public class RequestMetricsCollector : IRequestMetrics
{
    private long _totalRequests = 0;
    private long _failedRequests = 0;
    private long _totalLatencyMs = 0;
    
    public void RecordRequest(long latencyMs, bool success)
    {
        Interlocked.Increment(ref _totalRequests);
        Interlocked.Add(ref _totalLatencyMs, latencyMs);
        
        if (!success)
        {
            Interlocked.Increment(ref _failedRequests);
        }
    }
    
    public MetricsSnapshot GetSnapshot()
    {
        var total = Interlocked.Read(ref _totalRequests);
        var failed = Interlocked.Read(ref _failedRequests);
        var latency = Interlocked.Read(ref _totalLatencyMs);
        
        return new MetricsSnapshot
        {
            TotalRequests = total,
            FailedRequests = failed,
            AverageLatencyMs = total > 0 ? (double)latency / total : 0
        };
    }
}
 
// ✅ HttpClient Factory: Proper singleton pattern for HTTP
// In .NET, use IHttpClientFactory, not singleton HttpClient
services.AddHttpClient<IPaymentGateway, PaymentGateway>(client =>
{
    client.BaseAddress = new Uri("https://payments.example.com");
    client.DefaultRequestHeaders.Add("X-Api-Version", "2.0");
})
.AddTransientHttpErrorPolicy(p => 
    p.WaitAndRetryAsync(3, _ => TimeSpan.FromSeconds(1)));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

// ❌ WRONG: Per-request data in singleton
public class UserContextService : IUserContext
{
    public int CurrentUserId { get; set; } // ⚠️ SHARED ACROSS REQUESTS!
    
    public void SetUser(int userId)
    {
        CurrentUserId = userId; // Request A sets to 100
        // Request B sets to 200
        // Request A reads... 200! Wrong user!
    }
}
services.AddSingleton<IUserContext, UserContextService>(); // ❌
 
// ✅ FIX: Use scoped lifetime for per-request data
services.AddScoped<IUserContext, UserContextService>(); // Each request gets own instance
 
// ❌ WRONG: Singleton DbContext
services.AddSingleton<ApplicationDbContext>(); // ❌ NEVER DO THIS
 
// ✅ FIX: Use scoped lifetime
services.AddScoped<ApplicationDbContext>();
 
// ❌ WRONG: Singleton with unprotected mutable state
public class SessionTracker : ISessionTracker
{
    private readonly Dictionary<string, Session> _sessions = new(); // ⚠️ NOT THREAD-SAFE
    
    public void AddSession(string sessionId, Session session)
    {
        _sessions[sessionId] = session; // Concurrent access corrupts internal state
    }
}
services.AddSingleton<ISessionTracker, SessionTracker>(); // ❌
 
// ✅ FIX: Use concurrent collection
public class SafeSessionTracker : ISessionTracker
{
    private readonly ConcurrentDictionary<string, Session> _sessions = new();
    
    public void AddSession(string sessionId, Session session)
    {
        _sessions[sessionId] = session; // Thread-safe
    }
}
 
// ❌ WRONG: Singleton capturing scoped dependency
public class CachingOrderService : IOrderService
{
    private readonly ApplicationDbContext _db; // ⚠️ SCOPED! Captured by singleton!
    
    public CachingOrderService(ApplicationDbContext db)
    {
        _db = db; // This DbContext lives forever now
    }
}
services.AddSingleton<IOrderService, CachingOrderService>(); // ❌
services.AddScoped<ApplicationDbContext>(); // This becomes captive
 
// ✅ FIX: Inject scope factory for on-demand scoped resolution
public class SafeCachingOrderService : IOrderService
{
    private readonly IServiceScopeFactory _scopeFactory;
    
    public SafeCachingOrderService(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
    }
    
    public async Task<Order?> GetOrderAsync(int id)
    {
        await using var scope = _scopeFactory.CreateAsyncScope();
        var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
        return await db.Orders.FindAsync(id);
    }
}
services.AddSingleton<IOrderService, SafeCachingOrderService>(); // ✅

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

// ❌ Classic Singleton Pattern - avoid in modern applications
public class LegacyConfigurationManager
{
    private static LegacyConfigurationManager? _instance;
    private static readonly object _lock = new();
    
    public string DatabaseConnection { get; }
    
    private LegacyConfigurationManager()
    {
        DatabaseConnection = LoadFromFile("config.json");
    }
    
    public static LegacyConfigurationManager Instance
    {
        get
        {
            if (_instance == null)
            {
                lock (_lock)
                {
                    if (_instance == null)
                    {
                        _instance = new LegacyConfigurationManager();
                    }
                }
            }
            return _instance;
        }
    }
}
 
// Usage - tightly coupled, hard to test
public class OrderService
{
    public void ProcessOrder(Order order)
    {
        // Direct dependency on static instance
        var connString = LegacyConfigurationManager.Instance.DatabaseConnection;
        // How do you test this with a different configuration?
        // How do you mock LegacyConfigurationManager?
    }
}
 
// ✅ DI Singleton - modern, testable approach
public interface IConfigurationManager
{
    string DatabaseConnection { get; }
}
 
public class ConfigurationManager : IConfigurationManager
{
    public string DatabaseConnection { get; }
    
    public ConfigurationManager(IConfiguration config)
    {
        DatabaseConnection = config.GetConnectionString("Default")!;
    }
}
 
// Registration
services.AddSingleton<IConfigurationManager, ConfigurationManager>();
 
// Usage - loosely coupled, easily testable
public class OrderService
{
    private readonly IConfigurationManager _config;
    
    public OrderService(IConfigurationManager config)
    {
        _config = config; // Injected, mockable, testable
    }
    
    public void ProcessOrder(Order order)
    {
        var connString = _config.DatabaseConnection;
    }
}
 
// Testing is trivial
public class OrderServiceTests
{
    [Fact]
    public void ProcessOrder_UsesConfiguration()
    {
        var mockConfig = new Mock<IConfigurationManager>();
        mockConfig.Setup(c => c.DatabaseConnection).Returns("TestConnection");
        
        var service = new OrderService(mockConfig.Object);
        // Test with controlled configuration
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// Singleton with IDisposable for resource cleanup
public class BackgroundTaskScheduler : ITaskScheduler, IDisposable
{
    private readonly Timer _timer;
    private readonly CancellationTokenSource _cts;
    private bool _disposed;
    
    public BackgroundTaskScheduler(ILogger<BackgroundTaskScheduler> logger)
    {
        _cts = new CancellationTokenSource();
        _timer = new Timer(ExecutePendingTasks, null, 
            TimeSpan.Zero, TimeSpan.FromSeconds(30));
    }
    
    private void ExecutePendingTasks(object? state)
    {
        if (_cts.IsCancellationRequested) return;
        // Process tasks...
    }
    
    public void Dispose()
    {
        if (!_disposed)
        {
            _cts.Cancel();
            _timer.Dispose();
            _cts.Dispose();
            _disposed = true;
        }
    }
}
 
// For async cleanup, implement IAsyncDisposable
public class ConnectionPool : IConnectionPool, IAsyncDisposable
{
    private readonly Channel<DbConnection> _pool;
    private readonly List<DbConnection> _allConnections = new();
    
    public ConnectionPool(int poolSize, string connectionString)
    {
        _pool = Channel.CreateBounded<DbConnection>(poolSize);
        
        for (int i = 0; i < poolSize; i++)
        {
            var conn = new NpgsqlConnection(connectionString);
            conn.Open();
            _allConnections.Add(conn);
            _pool.Writer.TryWrite(conn);
        }
    }
    
    public async ValueTask DisposeAsync()
    {
        _pool.Writer.Complete();
        
        foreach (var conn in _allConnections)
        {
            await conn.CloseAsync();
            await conn.DisposeAsync();
        }
    }
}
 
services.AddSingleton<ITaskScheduler, BackgroundTaskScheduler>();
services.AddSingleton<IConnectionPool, ConnectionPool>();
 
// Container disposal happens at shutdown
public class Program
{
    public static async Task Main(string[] args)
    {
        var host = CreateHostBuilder(args).Build();
        
        try
        {
            await host.RunAsync();
        }
        finally
        {
            // Host disposal triggers singleton disposal
            await host.DisposeAsync();
            // BackgroundTaskScheduler.Dispose() called
            // ConnectionPool.DisposeAsync() called
        }
    }
}