C# Interview Questions and Answers

.NET uses a generational, compacting, tracing collector. New objects go to generation 0. Survivors are promoted to gen 1 then gen 2. Gen 0 collections are frequent and cheap because most objects die young; gen 2 collections are expensive and mark the whole heap.

Large objects of 85KB or more, such as big arrays, go to the Large Object Heap. It is not compacted by default to avoid moving costs, so it can fragment. ArrayPool<T> avoids repeated large allocations.

var buffer = ArrayPool<byte>.Shared.Rent(1_000_000);
try {
    // use buffer
} finally {
    ArrayPool<byte>.Shared.Return(buffer);
}

The GC is non-deterministic, so it does not replace IDisposable. Reduce pressure with pooling, Span<T> and structs, and measure with dotnet-counters or GC ETW events before optimising.

A classic deadlock happens in UI applications and classic ASP.NET when you block synchronously on async code with .Result or .Wait().

The awaited task wants to resume on the captured synchronisation context, but that context's single thread is blocked waiting for the task, so neither can proceed.

var data = GetDataAsync().Result; // deadlock in a UI/ASP.NET context

Fixes: go async all the way up and return Task instead of blocking, or use ConfigureAwait(false) in library code so continuations do not require the original context. ASP.NET Core has no synchronisation context, so this exact deadlock is less common there, but blocking still wastes threads and can starve the pool.

Other pitfalls include async void, unobserved task exceptions and not passing CancellationToken. Use Task.WhenAll for concurrency and IAsyncEnumerable<T> for asynchronous streams.