**Double-checked locking** is a classic pattern to initialize a singleton lazily without locking on every access. Naive implementations are broken on pre-.NET memory models; the correct version uses `volatile`: ```csharp private static volatile Singleton _instance; private static readonly object _lock = new object(); public static Singleton Instance { get { if (_instance is null) // first check (no lock) { lock (_lock) { if (_instance is null) // second check (inside lock) _instance = new Singleton(); } } return _instance; } } ``` The `volatile` keyword prevents the compiler/CPU from reordering the write to `_instance` before the constructor completes. **`Lazy` — the idiomatic alternative:** ```csharp private static readonly Lazy _lazy = new Lazy(() => new Singleton(), LazyThreadSafetyMode.ExecutionAndPublication); public static Singleton Instance => _lazy.Value; ``` `LazyThreadSafetyMode.ExecutionAndPublication` (the default) ensures the factory runs exactly once; all other threads block until it completes. | | Double-checked locking | `Lazy` | |---|---|---| | Correctness | Requires `volatile` — easy to get wrong | Correct by default | | Readability | Verbose | Concise | | Exception caching | Manual | Configurable (`PublicationOnly` retries) | | Async support | None | Use `AsyncLazy` (community) | **For async lazy initialization**, a common pattern: ```csharp private readonly Lazy> _connection = new Lazy>(() => ConnectAsync(), LazyThreadSafetyMode.ExecutionAndPublication); public Task GetConnectionAsync() => _connection.Value; ``` The `Task` is created once and awaited many times — safe because awaiting a completed `Task` is always safe.

C# Async & Concurrency

Task vs Thread

async/await basics

async void pitfalls

ConfigureAwait(false)

CancellationToken basics

Task.WhenAll vs Task.WhenAny

Classic .Result/.Wait() deadlock

SynchronizationContext explained

ValueTask vs Task

SemaphoreSlim for async locking

CancellationToken linking

ConcurrentDictionary and ConcurrentQueue

Interlocked operations

Parallel.For and Parallel.ForEach

PLINQ

lock statement and Monitor

System.Threading.Channels — producer/consumer

IAsyncEnumerable and async streams

ThreadPool internals

Thread-safe lazy initialization: Lazy<T> and double-checked locking

async in ASP.NET Core — scalability impact

Cancellation propagation patterns