Question 1

What is the difference between value types and reference types?

Accepted Answer

Value types (struct, int, double, bool, enum) hold their data directly; assignment copies the value. Reference types (class, string, array, delegate) hold a reference to the heap; assignment copies the reference, so both names share one object. Structs are value types; classes are reference types. string is a reference type but immutable, so it behaves like a value in practice. Boxing wraps a value type as an object on the heap and is a performance cost in hot paths.

Question 2

Why use StringBuilder instead of string concatenation?

Accepted Answer

string is immutable; each concatenation allocates a new string and copies both sides. Building a large string in a loop with += is O(n^2) in total characters copied. StringBuilder maintains a mutable buffer, so appends are amortized O(1). Use the plain + operator for a fixed number of concatenations, or string interpolation for readability. StringBuilder also supports Append, AppendLine, Insert, Replace, and a final ToString().

Question 3

When do you choose a struct over a class?

Accepted Answer

Structs are value types with copy semantics; classes are reference types with identity. Good structs are small, immutable, short-lived, and logically a single value (e.g. DateTime, a Point). Structs cannot inherit but can implement interfaces; they have no destructor and cannot be null unless nullable. Large structs copied often hurt performance; consider `in`/`ref readonly` for read-only passing. A mutable struct is a common bug source because copies don't observe mutations.

Question 4

What's the difference between a field and a property?

Accepted Answer

A field is a raw variable; a property is a member exposing get/set accessors backed (usually) by a field. Auto-properties ({ get; set; }) let the compiler create the backing field. Properties can validate, compute, or restrict access (private set, init-only). Properties are the public API convention; fields should generally be private. init-only setters allow object-initializer construction without full mutability.

Question 5

Is `var` the same as `dynamic`?

Accepted Answer

var is compile-time type inference: the compiler infers the static type from the initializer and enforces it. dynamic defers all type checking to runtime and boxes the call through the DLR — no IntelliSense, slower. Use var to avoid repetition when the type is obvious from the right-hand side; use explicit types when it aids readability. dynamic is for interop/COM/dynamic scenarios, not general use. var cannot be a parameter/return type; dynamic can.

Question 6

Interface vs abstract class in C# — when each?

Accepted Answer

A class can implement many interfaces but extend only one class. An abstract class can have state, constructors, and implemented members; an interface (pre-C# 8) only declared a contract. C# 8+ interfaces can have default implementations, blurring the line, but they cannot hold instance state. Use an interface to describe capability across unrelated types; use an abstract class to share common code. Interfaces are essential for dependency injection and mocking.

Question 7

What is LINQ and where does it execute?

Accepted Answer

LINQ gives a consistent query syntax/API (Where, Select, OrderBy, GroupBy) over in-memory collections and IQueryable sources. LINQ to Objects uses IEnumerable and runs in-process; LINQ to Entities (EF Core) builds an expression tree translated to SQL. Query execution is deferred until enumeration; that is why a query built but never iterated does nothing. ToList/ToArray force execution and materialize results, often needed before reusing a query. Because IQueryable is translated, some C# expressions cannot be translated and cause runtime errors.

Question 8

How does `using` relate to IDisposable?

Accepted Answer

`using` guarantees Dispose() is called when the scope exits, even if an exception is thrown. IDisposable is the standard contract for releasing unmanaged resources (files, connections, handles). using declarations (C# 8) dispose at the end of the enclosing scope without a block. Disposable objects should also be disposed in a try/finally equivalent, which using implements. Finalizers are a safety net and should not replace Dispose.

Question 9

What are nullable value types and nullable reference types?

Accepted Answer

Nullable value types (int?) wrap a value type so it can also be null; use .HasValue/.Value or the ?? operator. Nullable reference types (? annotations) are a compile-time feature that warns about possible null dereferences. The null-forgiving operator (!) suppresses the warning when you know better. The compiler uses flow analysis (e.g. after an `is null` check) to reduce warnings. NRTs do not add runtime checking; they are static analysis.

Question 10

What's the difference between const, readonly, and static?

Accepted Answer

const is a compile-time constant baked into callers; it is implicitly static and limited to primitives/strings. readonly is a runtime field set once in a declaration or constructor, allowing any type. Changing a const requires recompiling every assembly that referenced it; readonly avoids that. static belongs to the type, not an instance, and is initialized once. A static readonly field is a common pattern for shared immutable instances.

Question 11

How do async and await work under the hood?

Accepted Answer

async marks a method that can await; await suspends the method and returns control to the caller without blocking a thread. The compiler rewrites the method into a state machine that resumes on the captured context. An async method returns Task/Task<T>/ValueTask; async void is only for event handlers. ConfigureAwait(false) avoids capturing the synchronization context in library code; the UI context is captured by default. I/O-bound work should be async; CPU-bound work should not be faked with Task.Run in server code.

Question 12

What's the difference between a delegate and an event?

Accepted Answer

A delegate is a type-safe function pointer; Func/Action are built-in generic delegates. An event is a delegate field with restricted access: only the declaring type can invoke or reset it. Events implement the observer/publish-subscribe pattern and prevent external code from wiping subscribers. Subscribers must unsubscribe to avoid leaks when the publisher outlives them. Multicast delegates chain handlers and invoke them in order.

Question 13

How does garbage collection interact with IDisposable?

Accepted Answer

The GC is a generational, tracing collector; it frees managed memory when objects are unreachable, but at an unpredictable time. It does not free unmanaged resources (file handles, sockets) promptly — hence IDisposable. The Dispose pattern with a finalizer handles both: Dispose releases managed and unmanaged resources; the finalizer is a fallback. Suppress finalization (GC.SuppressFinalize) once Dispose runs, to avoid a second collection pass. Large object heap allocations and pinning affect GC performance.

Question 14

What are generic constraints and why use them?

Accepted Answer

Constraints (where T : class, struct, new(), IComparable, Base) restrict what types a generic can accept. They let the generic body call members the constraint guarantees (e.g. CompareTo with IComparable). new() enables `new T()`; class/struct constrain to reference/value types. C# generics are reified: type information exists at runtime, unlike Java's erasure. Constraints document requirements and produce compile-time errors instead of runtime failures.

Question 15

What is deferred execution and why does it matter?

Accepted Answer

IEnumerable queries are lazy: nothing runs until the sequence is enumerated. Each enumeration re-executes the query, which can cause repeated database calls or stale/duplicated results. Materialize with ToList/ToArray/ToDictionary when you need a stable snapshot or to avoid re-querying. yield return methods also defer and stream, evaluating one element at a time. Captured variables in a query reflect their value at enumeration time, not build time.

Question 16

Explain ref, out, and in parameters.

Accepted Answer

ref passes by reference; the argument must be initialized before the call and can be read and written. out passes by reference but the callee must assign it; the caller need not initialize it (classic TryX pattern). in passes by reference read-only, avoiding a copy for large structs without allowing mutation. `ref readonly` returns/provides a read-only reference. ref struct types (Span<T>) have stack-only restrictions.

Question 17

How does `yield return` work?

Accepted Answer

A method with yield return becomes a compiler-generated state machine implementing IEnumerable/IEnumerator. It produces values lazily, one per MoveNext, without building the whole collection. State (locals and position) is preserved between iterations, like a coroutine. It enables streaming large or infinite sequences in constant memory. The generated IDisposable lets early break/foreach dispose the iterator and run finally blocks.

Question 18

What is boxing and why is it a performance concern?

Accepted Answer

Boxing wraps a value type in an object on the heap; unboxing extracts it with a cast. It allocates and adds GC pressure and a copy, so it hurts in hot loops. Common triggers: storing a value in a non-generic collection (ArrayList), string concatenation with a struct, or calling an interface method on a struct without generics. Generic collections (List<int>) avoid boxing entirely. Interpolated string handlers / Span can avoid hidden allocations.

Question 19

What problem do Span and Memory solve?

Accepted Answer

Span is a stack-only, allocation-free view over contiguous memory (arrays, strings, stackalloc, native buffers). It enables slicing and zero-copy parsing without creating substrings or arrays. It cannot be used across await or stored on the heap; Memory is the heap-friendly counterpart. Ideal for high-performance string/serialization/numeric code. It has lifetime rules enforced by the compiler (no capturing in async or lambdas).

Question 20

How do you release resources asynchronously?

Accepted Answer

IAsyncDisposable provides DisposeAsync for resources that need async cleanup (e.g. DbConnection, streams). `await using` (C# 8) disposes asynchronously at scope exit. Implement the Dispose pattern for sync plus DisposeAsync where both are needed. Do not block on async cleanup with .Result — it can deadlock. ValueTask is often returned by DisposeAsync to avoid allocation in the common synchronous path.

Question 21

What does the params keyword do?

Accepted Answer

params T[] lets a method take a variable number of arguments. The compiler packs the arguments into an array, allocating when none are pre-existing. It must be the last parameter, and only one params parameter is allowed. Calling with an array directly avoids the wrapper allocation. Modern overloads often use ReadOnlySpan<T> for zero-allocation variadics.

Question 22

What do ?. and ?? do?

Accepted Answer

?. short-circuits a member access or call when the receiver is null, yielding null instead of throwing. ?[] is the indexer form. ?? returns the right operand when the left is null. ??= assigns only when the target is null. ?. returns a nullable type, so combine with ?? for a default.

Question 23

What is a [Flags] enum?

Accepted Answer

Combining [Flags] with powers-of-two values lets one enum hold a bitmask of options. Combine with |, test with HasFlag or bitwise &. ToString prints a comma-separated list when [Flags] is present. Forgetting [Flags] (or non-power-of-two values) breaks combinations. The underlying type can be byte/int/long to control size.

Question 24

How does string interpolation work?

Accepted Answer

$-prefixed strings embed expressions in { } and compile to string.Format. Format specifiers and alignment: {value:C}, {value,10}. Verbatim interpolated strings use $@"..." for multiline paths. In hot paths, interpolated string handlers / StringBuilder avoid allocations. Escaping a literal brace uses {{ and }}.

Question 25

When do you use List, Dictionary, or HashSet?

Accepted Answer

List is an ordered, indexable, resizable sequence allowing duplicates. Dictionary maps keys to values with O(1) average lookup. HashSet stores unique values with O(1) membership and set operations. Use SortedDictionary/SortedSet when you need ordering; queue/stack for FIFO/LIFO. Choose by the operations you need, and program to interfaces (IList, IDictionary).

Question 26

How do extension methods work?

Accepted Answer

A static method in a static class with `this` on the first parameter appears as an instance method. They let you add behavior to types you don't own (including interfaces and BCL types). Resolution prefers real instance methods over extensions. They are compile-time sugar and can't access private members. LINQ is built from extension methods on IEnumerable<T>.

Question 27

What are partial classes and partial methods?

Accepted Answer

partial splits a class/struct/interface across files that the compiler merges. Tooling (designers, source generators) uses it to keep generated code separate. partial methods let a generated file declare a hook the developer may implement. All parts must agree on modifiers like sealed/abstract and accessibility. They don't create separate types at runtime.

Question 28

What are exception filters (catch ... when)?

Accepted Answer

catch (Ex e) when (condition) only catches when the condition is true. If the condition is false, the search for a handler continues up the stack. Filters run before unwinding, so the stack is preserved and logging can be side-effect-free. They keep catch blocks focused and avoid rethrow-with-if patterns. A filter that itself throws is treated as false.

Question 29

What are value tuples?

Accepted Answer

(int, string) is a ValueTuple struct with value equality and no heap allocation. Elements can be named: (int Count, string Name). Deconstruct with var (count, name) = pair; or by position. They are good for small transient groupings but poor as public APIs that need meaning. Tuple equality compares element-wise in order.

Question 30

What are C# records?

Accepted Answer

A record is a reference type with value-based equality and a concise positional syntax. The compiler generates a constructor, init-only properties, Equals, GetHashCode, and ToString. with-expressions create a copy with some properties changed (non-destructive mutation). record struct gives the same features as a value type. Use records for immutable data/DTOs and value semantics.

Question 31

How does C# pattern matching work?

Accepted Answer

is patterns type-test and bind: if (o is Point { X: 0 } p). switch expressions with patterns and when guards replace long if/else chains. Property and positional patterns destructure objects and records. List patterns (C# 11+) match sequences. Exhaustiveness is encouraged with a discard arm.

Question 32

What are async streams (IAsyncEnumerable)?

Accepted Answer

An async iterator uses async IAsyncEnumerable<T> with yield return and awaits. Consume with await foreach, optionally with WithCancellation. They stream data as it becomes available without buffering everything. EnumerateAsync needs [EnumeratorCancellation] to flow the token. Great for paged APIs, file reads, and realtime data.

Question 33

Compare lock, Monitor, and Interlocked.

Accepted Answer

lock(obj) is sugar for Monitor.Enter/Exit with a try/finally. Monitor adds TryEnter with timeout, Wait/Pulse for signaling. Interlocked provides lock-free atomic operations (Increment, CompareExchange). Never lock on `this`, strings, or a Type — external code can deadlock you. Prefer System.Threading.Lock (modern) or dedicated lock objects.

Question 34

What are the DI lifetimes and their pitfalls?

Accepted Answer

Singleton: one instance for the app; scoped: one per scope/request; transient: new each resolve. Captive dependency: injecting a scoped service into a singleton pins it forever. Resolve scoped services per request via the request scope, not the root provider. IDisposable services are disposed when their scope ends. Constructor injection is preferred; avoid the service-locator anti-pattern.

Question 35

What are expression trees?

Accepted Answer

A lambda assigned to Expression> becomes a data structure describing the code. IQueryable providers (EF Core) translate the tree into SQL instead of executing it in memory. You can walk or rewrite the tree (e.g. add filters, build dynamic predicates). Not every C# expression can be translated, which causes runtime translation errors. Compile() turns the tree back into an executable delegate.

Question 36

What is an indexer?

Accepted Answer

An indexer (this[int i]) lets an object be indexed like an array. It can have get/set (and init) and multiple parameters (this[int x, int y]). Indexers are properties in disguise and don't require a backing collection. They enable dictionary-like syntax on custom types. Range/Index (C# 8) can be accepted for slicing-like access.

Question 37

What are covariance and contravariance in generics?

Accepted Answer

out T makes a generic covariant: IEnumerable is assignable to IEnumerable

Question 38

How do Tasks relate to the thread pool?

Accepted Answer

Task.Run queues work to the thread pool for CPU-bound work; async I/O doesn't consume a thread while waiting. The thread pool grows under load and has hysteresis; blocking many threads starves it. LongRunning hints a dedicated thread. Never block on .Result/.Wait() in async code — that can deadlock and exhaust the pool. ValueTask avoids allocation for frequently synchronous completions.

Question 39

What is reflection used for and what does it cost?

Accepted Answer

Reflection inspects and invokes members at runtime (typeof, GetType, Activator, MethodInfo.Invoke). It powers serializers, ORMs, DI, and attribute-driven frameworks. Costs: slower calls, no compile-time checking, trimming/AOT issues. Cache MethodInfo/delegates and use source generators or compiled expressions for hot paths. Attributes are the common metadata read via reflection.

Question 40

What's the difference between virtual and abstract methods?

Accepted Answer

virtual provides a base implementation that derived classes may override. abstract declares a method with no body; derived classes must override it. A class with any abstract member must itself be abstract and cannot be instantiated. Overrides use the override keyword; hiding without it warns and is usually a bug. abstract members can be combined with abstract properties and events.