roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Answer C# interview questions at depth, from value and reference types to async/await and LINQ. Covers types and generics, collections, concurrency, the .NET runtime and GC, and testing.
529 of 529 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 529 new. 0 cut, outside your plan.
C# seldom has a loop to itself. It is the language round inside a Unity or game-studio loop, a .NET backend loop or a desktop and services loop, and it tends to come early, because every later round assumes it. The opening questions are nearly always about value and reference semantics: what gets copied when a struct comes back from a list indexer, when an `int` is boxed, what `ref` and `out` change at the call site. Game teams then weigh the language against the frame budget, asking what a lambda that captures a local allocates and why a LINQ query inside `Update` shows up in the profiler. Teams on the data side follow LINQ into the database instead, where an `IQueryable` is translated to SQL and an `IEnumerable` pulls every row into memory first. Seniority shows in how far below the syntax an answer is willing to go. The first rung is predicting output; the next is naming the rule that produced it, such as deferred execution or the state machine an `async` method compiles to. Senior conversations leave the language for the runtime beneath it: p99 latency spikes that line up with gen 2 collections, a thread count that climbs one step every half second while the CPU sits idle, whether Native AOT is worth losing runtime code generation, and how a rewrite was proved faster with a benchmark rather than a stopwatch.
The plan starts with what every later answer leans on. The [type system](/topics/lang-csharp-type-system) comes in the first group because copies, boxing and equality return in almost every follow-up, and the modeling group then builds on it: classes and interfaces, [records](/topics/lang-csharp-records) with their generated equality, [pattern matching](/topics/lang-csharp-patterns) over them, and [nullable reference types](/topics/lang-csharp-nullability), whose guarantees end where compilation does. [Generics](/topics/lang-csharp-generics) and delegates come before [iterators](/topics/lang-csharp-iterators) and [LINQ](/topics/lang-csharp-linq) for a structural reason: most LINQ operators are generic extension methods that take a delegate and return a lazy sequence, so their surprises are generics, closure and `yield` surprises. The standard library follows, putting collections and strings beside the [base class library](/topics/be-dotnet-bcl) that serializes, streams and timestamps them, and [exceptions](/topics/lang-csharp-exceptions) with disposal close the everyday language. From concurrency on, each language branch sits next to the runtime part it completes. [Async and await](/topics/lang-csharp-async) pair with the [thread pool and parallel loops](/topics/be-dotnet-async-tpl) the continuations run on; [spans and pooling](/topics/lang-csharp-memory) pair with the [garbage collector](/topics/be-dotnet-gc) they relieve and with [measurement](/topics/be-dotnet-performance), the evidence any claim about either needs. The compilation model puts the [JIT, tiering and Native AOT](/topics/be-dotnet-clr-runtime) ahead of [reflection and source generators](/topics/lang-csharp-metaprogramming), since trimming and ahead-of-time compilation are a large part of why source generation is taking over work that runtime reflection used to do. The last two groups are about the project around the code: [language versions and analyzers](/topics/lang-csharp-evolution) that decide what compiles and what fails the build, the [.NET CLI](/topics/dev-dotnet-cli), NuGet, the [generic host](/topics/be-dotnet-hosting) a non-web program ships in, and the test frameworks, from [xUnit](/topics/dev-xunit) to NUnit and MSTest.
A Unity developer and a backend developer should spend their hours differently. For Unity work the first five groups and Memory & Performance carry the loop, while the thread pool and the generic host matter far less. A backend candidate gets the most from the concurrency and runtime groups, where the long conversations settle. With the interview days away, narrow importance to must know and keep the low end of level even at senior, because a follow-up to an async answer often lands back on copies and boxing. Given several weeks, switch study order to by topics: the later groups pair language and runtime on purpose, and a garbage collector question reads differently once spans and pooling come just before it. Of the three test frameworks, learn the one your team uses well and the others by contrast. The plan is the language and its runtime, not a framework. Endpoints, middleware and the dependency-injection lifetimes most .NET services are built on are in the [ASP.NET Core roadmap](/roadmaps/aspnet-core). The engine around a game, from its architecture to rendering and game math, is in the [Game Developer roadmap](/roadmaps/game-developer), where C# is one engine language among several.
C# seldom has a loop to itself. It is the language round inside a Unity or game-studio loop, a .NET backend loop or a desktop and services loop, and it tends to come early, because every later round assumes it. The opening questions are nearly always about value and reference semantics: what gets copied when a struct comes back from a list indexer, when an int is boxed, what ref and out change at the call site. Game teams then weigh the language against the frame budget, asking what a lambda that captures a local allocates and why a LINQ query inside Update shows up in the profiler. Teams on the data side follow LINQ into the database instead, where an IQueryable is translated to SQL and an IEnumerable pulls every row into memory first.
Seniority shows in how far below the syntax an answer is willing to go. The first rung is predicting output; the next is naming the rule that produced it, such as deferred execution or the state machine an async method compiles to. Senior conversations leave the language for the runtime beneath it: p99 latency spikes that line up with gen 2 collections, a thread count that climbs one step every half second while the CPU sits idle, whether Native AOT is worth losing runtime code generation, and how a rewrite was proved faster with a benchmark rather than a stopwatch.
The plan starts with what every later answer leans on. The type system comes in the first group because copies, boxing and equality return in almost every follow-up, and the modeling group then builds on it: classes and interfaces, records with their generated equality, pattern matching over them, and nullable reference types, whose guarantees end where compilation does.
Generics and delegates come before iterators and LINQ for a structural reason: most LINQ operators are generic extension methods that take a delegate and return a lazy sequence, so their surprises are generics, closure and yield surprises. The standard library follows, putting collections and strings beside the base class library that serializes, streams and timestamps them, and exceptions with disposal close the everyday language.
From concurrency on, each language branch sits next to the runtime part it completes. Async and await pair with the thread pool and parallel loops the continuations run on; spans and pooling pair with the garbage collector they relieve and with measurement, the evidence any claim about either needs. The compilation model puts the JIT, tiering and Native AOT ahead of reflection and source generators, since trimming and ahead-of-time compilation are a large part of why source generation is taking over work that runtime reflection used to do.
The last two groups are about the project around the code: language versions and analyzers that decide what compiles and what fails the build, the .NET CLI, NuGet, the generic host a non-web program ships in, and the test frameworks, from xUnit to NUnit and MSTest.
A Unity developer and a backend developer should spend their hours differently. For Unity work the first five groups and Memory & Performance carry the loop, while the thread pool and the generic host matter far less. A backend candidate gets the most from the concurrency and runtime groups, where the long conversations settle.
With the interview days away, narrow importance to must know and keep the low end of level even at senior, because a follow-up to an async answer often lands back on copies and boxing. Given several weeks, switch study order to by topics: the later groups pair language and runtime on purpose, and a garbage collector question reads differently once spans and pooling come just before it. Of the three test frameworks, learn the one your team uses well and the others by contrast.
The plan is the language and its runtime, not a framework. Endpoints, middleware and the dependency-injection lifetimes most .NET services are built on are in the ASP.NET Core roadmap. The engine around a game, from its architecture to rendering and game math, is in the Game Developer roadmap, where C# is one engine language among several.