C# Interview Help — AI for .NET, LINQ, Async/Await & Generics

1. Type system & memory

struct vs class (value vs reference), boxing/unboxing, string immutability, nullable types, and the stack-vs-heap mental model. "Is a struct passed by value?" is a classic filter. The AI gives the precise answer and the gotcha.

2. LINQ, async & idioms

LINQ (deferred execution, IEnumerable vs IQueryable), yield return, async/await and the Task model (and why async void is dangerous), delegates/events, and IDisposable/using. The AI surfaces deferred-execution and async pitfalls interviewers love.

3. GC, generics & coding

Generational GC, generics and constraints, and DS&A solved idiomatically in C#/.NET. The AI returns idiomatic C# with complexity.

1. "struct vs class — value vs reference type?"

A class is a reference type (the variable holds a reference; assignment copies the reference), while a struct is a value type copied in full on assignment and when passed by value. Mention that boxing a struct into object allocates on the heap, and that mutable structs are a known footgun.

2. "What is boxing, and why does it cost?"

Boxing wraps a value type in a heap-allocated object so it can be treated as a reference type; unboxing copies it back out. The cost is the allocation plus GC pressure — which is exactly why generics (List<T>) exist, to avoid boxing in collections.

3. "What does yield return do, and what is deferred execution?"

An iterator method with yield return is compiled into a state machine that produces values lazily — nothing runs until the caller enumerates it. Connect this to LINQ: query operators like Where and Select are deferred and only execute when iterated (e.g. by ToList() or a foreach).

4. "IEnumerable vs IQueryable — what's the difference?"

IEnumerable<T> evaluates LINQ in memory with delegates; IQueryable<T> builds an expression tree a provider (e.g. EF Core) translates to SQL and runs at the source. Getting this wrong pulls a whole table into memory — interviewers probe it for exactly that reason.

5. "Explain async/await. Why is async void dangerous?"

await releases the thread while an awaited Task is in flight and resumes on completion — it is about freeing threads, not creating them (contrast with spinning up a Thread). async void can't be awaited and swallows exceptions into the synchronization context, so it's reserved for event handlers; everything else returns Task.

6. "How does the .NET GC work, and where does IDisposable fit?"

The GC is generational (gen 0/1/2) and reclaims managed memory automatically, so you don't free objects by hand. IDisposable plus using exists for unmanaged resources (file handles, sockets, DB connections) that need deterministic release the GC can't guarantee timing for.

7. "Delegates, events, and lambdas — how do they relate?"

A delegate is a type-safe function pointer; a lambda is concise syntax for an anonymous method assignable to a delegate (e.g. Func<>/Action<>); an event is a publish/subscribe wrapper over a delegate that restricts callers to +=/-=. Mention nullable reference types as a modern follow-up on null-safety.

How to prepare for a C# interview

• Write a tiny program that prints before and after mutating a struct vs a class passed to a method — seeing value-copy vs reference behavior cements the most common filter question.
• Trace a deferred LINQ query: add Console.WriteLine inside a Where predicate and observe it not firing until you call ToList() or foreach.
• Reproduce a sync-over-async deadlock (calling .Result on an async method in a UI/context) and fix it with await and ConfigureAwait(false) so you can explain the trap.
• Solve DS&A in idiomatic C# using LINQ and the right collections (Dictionary, HashSet, List), and be ready to state Big-O for each.

Pair this with broader coding interview help, Java interview help for JVM-vs-CLR contrasts, and system design for senior .NET rounds.