C# Advanced Topics

Multithreading allows a program to perform multiple operations concurrently. In C#, the modern guidance is a layered approach — choose the highest abstraction that fits:

1. async/await — preferred for I/O-bound concurrency (no threads created):

public async Task FetchDataAsync(string url, CancellationToken ct)
{
    using var client = new HttpClient();
    return await client.GetStringAsync(url, ct);
}

async/await releases the calling thread while waiting; when the I/O completes, execution resumes (often on a thread pool thread). No wasted threads blocking.

2. Task.Run() — for CPU-bound work on the thread pool:

int result = await Task.Run(() => HeavyCpuComputation());

3. Parallel.For / Parallel.ForEach — data parallelism:

Parallel.ForEach(items, item => Process(item));
await Parallel.ForEachAsync(items, ct, async (item, t) => await ProcessAsync(item, t));

4. Channel (System.Threading.Channels) — async producer/consumer pipelines:

var channel = Channel.CreateBounded(capacity: 100);
// Producer
await channel.Writer.WriteAsync(work);
// Consumer
await foreach (var item in channel.Reader.ReadAllAsync())
    await HandleAsync(item);

5. Raw Thread class — rarely needed in modern code. Use for very specific scenarios (STA COM threads, etc.).

Synchronization:

Common pitfalls: race conditions on shared mutable state, deadlocks (locking in async code — avoid), async void (exceptions uncatchable — use only in event handlers).

Interviewers probe: why is async/await better than creating Thread objects for web server code? Thread-per-request doesn't scale — a 4-core server with 1,000 concurrent requests would block 1,000 threads. async/await lets thread pool threads handle many concurrent operations without blocking.

A delegate is a type that holds a reference to a method — a type-safe function pointer. Delegates enable passing methods as parameters, storing them in variables, and invoking them later.

Defining and using a delegate:

// Custom delegate type — rarely needed in modern C#
delegate int MathOp(int a, int b);

MathOp add = (a, b) => a + b;
Console.WriteLine(add(3, 4)); // 7

Built-in generic delegates (prefer these over custom types):

Multicast delegates — += chains methods; -= removes them:

Action log = Console.WriteLine;
log += s => File.AppendAllText("log.txt", s + "\n");
log("Hello"); // calls both methods

Events — expose a delegate with restricted access (external code can only subscribe/unsubscribe, not invoke directly):

public class Button
{
    public event EventHandler? Clicked;
    protected virtual void OnClicked() => Clicked?.Invoke(this, EventArgs.Empty);
}

Closures — lambdas capture variables from enclosing scope:

int multiplier = 3;
Func triple = x => x * multiplier; // captures 'multiplier'

Classic closure bug in loops:

// BUG — all lambdas capture the same 'i' variable
var actions = Enumerable.Range(0, 3).Select(i => (Action)(() => Console.WriteLine(i))).ToList();
// Fix: i is already a fresh copy per iteration in C# foreach over LINQ range — but be careful with manual for loops

Interviewers probe: difference between delegate and event? An event wraps a delegate but prevents external code from invoking it directly or replacing the invocation list — only the declaring class can raise the event.

LINQ (Language Integrated Query) is a set of language keywords and extension methods that enable querying any data source implementing IEnumerable or IQueryable using a consistent, readable syntax.

Two syntax styles:

var numbers = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// Query syntax (SQL-like)
var evens = from n in numbers
            where n % 2 == 0
            orderby n descending
            select n * n;

// Method (fluent) syntax — more common in production code
var evens2 = numbers
    .Where(n => n % 2 == 0)
    .OrderByDescending(n => n)
    .Select(n => n * n);

Key operators:

• Filtering: Where, OfType
• Projection: Select, SelectMany (flatten nested collections)
• Ordering: OrderBy, OrderByDescending, ThenBy, ThenByDescending
• Grouping: GroupBy
• Joining: Join, GroupJoin
• Aggregation: Count, Sum, Average, Min, Max, Aggregate
• Element access: First, FirstOrDefault, Single, SingleOrDefault, ElementAt
• Set operations: Distinct, Union, Intersect, Except
• Quantifiers: Any, All, Contains
• Partitioning: Take, Skip, TakeWhile, SkipWhile, Chunk (.NET 6+)

.NET 6+ new methods: MinBy(), MaxBy(), DistinctBy(), ExceptBy(), IntersectBy(), UnionBy(), Chunk().

Deferred vs immediate execution:

var query = numbers.Where(n => n > 5); // deferred — not executed yet
var list = query.ToList();              // immediate — executes now

LINQ queries are lazy by default. Call ToList(), ToArray(), ToDictionary(), Count(), First(), etc. to force execution. Be aware of multiple enumeration — if you iterate a deferred query twice, it executes twice; materialize with ToList() if needed.

EF Core LINQ (IQueryable): translates LINQ to SQL. Use AsNoTracking() for read-only queries. Avoid calling .ToList() in the middle of a query chain — let EF Core translate as much as possible to SQL.

Interviewers probe: First() vs FirstOrDefault() — First() throws if no element matches; FirstOrDefault() returns null/default. Use SingleOrDefault() when you expect exactly 0 or 1 results (throws on 2+).

Generics allow you to write type-parameterized code — classes, methods, and interfaces that work with any type while preserving compile-time type safety. They eliminate the need for casting and boxing that was common with non-generic ArrayList or object-based code.

Basic usage:

// Generic method
T Max(T a, T b) where T : IComparable => a.CompareTo(b) >= 0 ? a : b;

// Generic class
public class Repository where T : class
{
    private readonly List _store = new();
    public void Add(T item) => _store.Add(item);
    public IEnumerable GetAll() => _store.AsReadOnly();
}

Generic constraints:

Variance (for generic interfaces and delegates):

• Covariance (out T): IEnumerable can be assigned to IEnumerable because IEnumerable is covariant.
• Contravariance (in T): Action can be assigned to Action because Action is contravariant.

C# 11 — static abstract interface members:

// Generic math — works with int, double, decimal, etc.
T Sum(IEnumerable values) where T : INumber =>
    values.Aggregate(T.Zero, (a, b) => a + b);

This is how System.Numerics.INumber works in .NET 7+.

Performance benefit: List stores int values directly on the heap without boxing. The legacy ArrayList stored everything as object, requiring boxing for value types — a hidden allocation on every Add.

Interviewers probe: what is the difference between List and List? List boxes value types and loses type safety at compile time. List is typed — no boxing for value types, compile-time type checking, no casts needed.

Async programming in C# uses async/await to write non-blocking code that reads linearly, like synchronous code, while allowing the runtime to do other work while waiting.

Core mechanics:

public async Task FetchUserAsync(int id, CancellationToken ct = default)
{
    // Returns Task, doesn't block a thread while waiting
    var response = await _httpClient.GetAsync($"/users/{id}", ct);
    response.EnsureSuccessStatusCode();
    return await response.Content.ReadAsStringAsync(ct);
}

await suspends the method at that point, returns control to the caller (freeing the thread), and resumes when the awaited operation completes.

Return types:

ConfigureAwait(false) — in library code, prevents capturing the synchronization context. Avoids deadlocks in some legacy environments (WinForms, ASP.NET non-Core). In ASP.NET Core, there is no synchronization context, so it's less critical but still a good practice for libraries.

CancellationToken — always accept and pass through in library code:

public async Task DoWorkAsync(CancellationToken ct)
{
    await Step1Async(ct);
    ct.ThrowIfCancellationRequested();
    await Step2Async(ct);
}

ValueTask — use instead of Task when the method frequently completes synchronously (e.g., cache hits):

public ValueTask GetUserAsync(int id)
{
    if (_cache.TryGetValue(id, out var user))
        return ValueTask.FromResult(user); // no allocation
    return new ValueTask(FetchFromDbAsync(id));
}

Common pitfalls:

• .Result / .Wait() — blocks the thread and can cause deadlocks in UI/legacy ASP.NET contexts. Always await.
• async void — exceptions propagate to the SynchronizationContext, not to the caller. Use Task-returning methods.
• Fire-and-forget — not awaiting a Task means exceptions are silently swallowed. Log carefully or use structured approaches.

.NET 9 addition: Task.WhenEach() — process tasks as they complete, without waiting for all:

await foreach (var result in Task.WhenEach(task1, task2, task3))
    Console.WriteLine(await result);

Interviewers probe: I/O-bound vs CPU-bound — async/await is for I/O-bound operations (network, disk, DB). For CPU-bound work, use await Task.Run(() => HeavyComputation()) to move the work to a thread pool thread.

These three interfaces form a hierarchy in System.Collections.Generic, each adding more capability:

When to use each in method signatures:

• Accept IEnumerable as a parameter when you only need to iterate — this is the most flexible, accepting arrays, List, LINQ results, and any other sequence.
• Accept ICollection when you need to add/remove or check Count.
• Accept IList only when you need random index access.
• Return IReadOnlyList or IReadOnlyCollection from public APIs to prevent callers from mutating your internal collection.

Concrete types: List implements all three. T[] (array) implements IList but is fixed-size (Add/Remove throw). LinkedList only implements ICollection.

Performance note: LINQ's Count() extension method checks if the source implements ICollection first and uses .Count directly (O(1)) rather than enumerating — always keep this in mind when designing collection return types.

Before C# 8, all reference type variables could be null, and the compiler gave no warnings about potential NullReferenceException. C# 8 introduced nullable reference types as an opt-in feature.

Enabling it (in .csproj — on by default in new .NET 6+ projects):

enable

Effect:

• string is now non-nullable by default — the compiler warns if you assign null or dereference without a null check.
• string? explicitly declares a nullable reference type — callers know to check for null.
• null! (null-forgiving operator) suppresses the warning when you know it's safe.

string name = null;          // Warning: cannot assign null to non-nullable
string? nickname = null;     // OK — explicitly nullable
Console.WriteLine(name.Length);    // Warning: dereference of possibly null
Console.WriteLine(nickname?.Length ?? 0); // OK — null-checked

Why it matters: NullReferenceException is one of the most common runtime exceptions. Nullable reference types move the detection from runtime to compile time, drastically reducing null bugs in large codebases. The .NET BCL itself is fully annotated.

Common gotcha — [NotNull], [MaybeNull] attributes: these flow-analysis attributes (in System.Diagnostics.CodeAnalysis) let you annotate methods whose nullability contract the compiler can't infer from the signature alone:

bool TryGet([NotNullWhen(true)] out string? value) { ... }

Records (introduced in C# 9) are a class (or struct) type with built-in value-based equality, immutability support, and concise syntax.

Reference record (class-based):

public record Person(string Name, int Age);

var alice = new Person("Alice", 30);
var alice2 = new Person("Alice", 30);
Console.WriteLine(alice == alice2); // True — value equality by default

var olderAlice = alice with { Age = 31 }; // non-destructive mutation

Record struct (C# 10+, value type):

public readonly record struct Point(double X, double Y);

What the compiler generates automatically:

• Equals() and == based on all properties
• GetHashCode() based on all properties
• ToString() showing property names and values
• Positional constructor and deconstructor
• with expression support

When to use records:

• DTOs (data transfer objects) passed between layers
• Value objects in domain-driven design (money amounts, coordinates)
• Command/query models in CQRS patterns
• Any type where two instances with the same data should be considered equal

When NOT to use records:

• Entities with identity (a Customer is the same Customer even if their address changes — use a class with an Id)
• Mutable objects with complex behavior

Interviewers probe: difference between record and a class with overridden Equals? Records synthesize all the equality plumbing; classes require manual implementation and it's error-prone.

Dependency injection is a design pattern where a class receives its dependencies from an external source rather than creating them itself. .NET has a built-in DI container in Microsoft.Extensions.DependencyInjection.

Registering services:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton(builder.Configuration);
builder.Services.AddScoped();
builder.Services.AddTransient();

Three lifetimes:

Captive dependency problem: injecting a Transient or Scoped service into a Singleton — the shorter-lived service gets "captured" and lives as long as the Singleton, defeating the purpose of its lifetime. .NET's built-in container throws InvalidOperationException for Scoped-in-Singleton at startup (with ValidateScopes enabled).

Constructor injection (standard pattern):

public class OrderService(IOrderRepository repo, ILogger logger)
{
    public async Task PlaceOrderAsync(Order order)
    {
        logger.LogInformation("Placing order {Id}", order.Id);
        await repo.SaveAsync(order);
    }
}

Why DI matters: testability (inject mocks), loose coupling (depend on interfaces), lifecycle management, and cross-cutting concerns (logging, caching) via decorators.