C# language semantics and ASP.NET Core service internals for Microsoft-stack interviews.
10 published across 5 topics.
.NET and C# fundamentals58 short answers on one page, for revising rather than studying.Value versus reference types, generics and variance, LINQ evaluation, records, and nullable references.
A value type stores its data inline wherever it is declared and is copied on every assignment, while a reference type stores a pointer to a heap object. Nullable reference types are compile-time flow analysis that emits warnings and is erased before execution, so they guarantee nothing at runtime.
A class gives reference identity, a struct gives value semantics and lives inline, and a record is a class with value-based equality and a copy-with-changes syntax generated for you. The decision is about identity and copying cost, not about which one is newest.
The task model, synchronisation context and deadlocks, cancellation, and parallelism choices.
A CancellationToken is cooperative: nothing is stopped for you, and work continues until something checks the token or an awaited call observes it. Propagation breaks wherever a token is accepted and not passed on, which is why the fix is usually threading it through rather than adding a check.
An await captures the current SynchronizationContext and posts its continuation back to it, so blocking that same context with .Result deadlocks on ASP.NET Framework and UI threads. ASP.NET Core has no such context, so the failure there is thread-pool starvation instead. The fix is async all the way up.
Generational GC, large object heap, boxing costs, spans, and diagnosing memory pressure.
The GC segregates the heap into generations on the assumption that most objects die young, collecting gen0 often and gen2 rarely, with large objects on a separate heap that is not compacted by default. Allocating less means removing boxing and using Span<T> over pooled or stack memory.
Span is a stack-only view over memory you already have, so slicing it costs nothing while Substring allocates a new string and copies. It removes allocations rather than making them faster, which is the right lever in a runtime where the cost is collection pressure rather than the allocation itself.
Middleware pipeline, DI lifetimes, configuration and options, minimal APIs, and hosting.
Singleton is one instance per application, scoped one per request, transient one per resolution. A scoped service injected into a singleton is captured for the life of the process, so a DbContext ends up shared across concurrent requests; scope validation catches it in Development, and IServiceScopeFactory is the fix.
The pipeline is an ordered list you assembled, and authorisation cannot decide anything before routing has selected an endpoint to decide about. Registered in the wrong order it either runs against nothing or never runs at all, and neither produces an error - the request simply succeeds.
Change tracking, query translation and client evaluation, migrations, and performance tuning.
The context snapshots every entity it loads so it can work out what changed at save time, which is useful for a handful of entities and pure overhead for a read. AsNoTracking removes the snapshot, and the same mechanism explains why a stray mutation on a tracked entity gets written even though you never called Update.
Start from the generated SQL, not the LINQ: most slowness is too many columns, a cartesian Include, or a lazy-loaded navigation firing once per row. Change tracking adds snapshot memory and fix-up work on top, which AsNoTracking and a Select projection remove.