What is the difference between managed and unmanaged code in .NET?

What is boxing and unboxing in C#?

What are the differences between value types and reference types in C#?

What are the five access modifiers in C# and when do you use each?

Why should you override the ToString() method?

What is the difference between int.Parse and int.TryParse?

What are the new features introduced in C# 7 (and later) that you use regularly?

What is the difference between a class and a struct in C#?

What is the difference between IEnumerable<T> and List<T>?

How do operator overloading rules work in C#, and which operators are excluded from overloading?

What are discard variables in C# and in which scenarios are they typically used?

How do named and optional arguments work in C#, and what restrictions apply to their usage?

What are default interface methods in C# 8 and what are their key design constraints?

What distinguishes an indexer from a property in C# and when would you use each?

What are local functions in C# and how do they differ from anonymous functions and lambdas?

What is deconstruction in C# and what contract must a type satisfy to support it?

What is the difference between the tuple syntax and the ValueTuple type in C#?

What do the checked and unchecked contexts control in C# arithmetic?

What exactly does the char type represent in C# and why cannot it store arbitrary Unicode characters?

What are records and how do they differ semantically from ordinary classes in C#?

What is string interning and what are its implications for equality and memory?

What is the null-conditional operator and what are its best-practice usage patterns?

What are the rules governing method overloading in C# and what does not count in a signature?

What constructs in C# can be called extension methods and what are their limitations?

Are strings mutable or immutable in C#?

What is a verbatim string literal and when do you use it?

What is the difference between string and StringBuilder?

What are the differences between implicit and explicit type conversions in C#?

What is a nullable type and how is it used in C#?

What are the StringComparison modes in .NET and when should you prefer ordinal over culture-aware comparison?

What formatting and parsing traps does the current culture create, and how do you avoid them?

When should you choose DateTimeOffset over DateTime, and what are the risks of mixing them?

What are DateOnly and TimeOnly, and what problems do they solve that DateTime cannot?

What are the pitfalls of TimeSpan arithmetic and how do the Total properties differ from the component properties?

How do int.Parse, int.TryParse, and Convert.ToInt32 differ, and when is each the right choice?

What do the standard numeric format specifiers such as N, F, C, and G mean, and what is the difference between the 0 and # custom placeholders?

How does string interpolation compare to String.Format and string.Concat, and when is each appropriate?

What are the differences between UTF-8 and UTF-16 encoding, and what role does the BOM play?

What encoding round-trip risks exist when converting bytes to strings and back, and how do you avoid data loss?

What is the relationship between char, Rune, and surrogate pairs in .NET text processing?

What is the difference between string.Trim and string.IsNullOrWhiteSpace, and when should each be used?

What are the common pitfalls of string.Split and string.Join, and how do you avoid them?

How does Span<char> enable allocation-free string slicing, and what are its constraints?

Why do string comparisons inside dictionaries and hash sets depend on the comparer, and what is the default behavior?

What is the difference between an abstract class and an interface in C#?

What are the four pillars of OOP and how does C# support each?

What is the difference between virtual, override, and abstract methods?

What is method hiding with the new keyword and how does it differ from overriding?

How do you decide between inheritance (is-a) and composition (has-a) in C#?

What are static constructors and when do they run?

How does a derived class invoke a specific base constructor?

What is a partial class and why would you split a class across files?

What are nested types in C# and what can they access in the enclosing type?

What is the difference between a sealed class and a static class?

What are the different kinds of polymorphism in C#?

What is the difference between abstract, virtual, and new (hiding) members in C# inheritance?

What do sealed classes and sealed methods do, and why would you apply sealing in library design?

How does covariance and contravariance work in C# interfaces and delegates, and what are its limits?

What is the difference between internal, protected, protected internal, and private protected in C#?

When should you prefer composition over inheritance in C#, and what are the typical trade-offs?

How do static classes and static members initialize, and what ordering rules apply to static constructors?

What are the trade-offs of using an interface versus an abstract class as a base abstraction?

What is the IDisposable pattern for inheritance hierarchies, and how do Dispose and the finalizer interact?

How should you design properties for clean encapsulation, and what does dependency inversion mean for setters?

What are init-only setters in C# 9 and how do they differ from property setters?

What are readonly members in C# 8, and how do they prevent defensive copies in structs?

What accessibility rules apply to nested classes, and what access do they have to the containing type?

How do nullable reference types work in class design, and what caveats remain at runtime?

What is the difference between the stack and the heap in C#?

How does the .NET garbage collector work?

What is a memory leak in .NET and how do you find one?

When should you use a struct instead of a class in C#?

What is boxing and unboxing and why should you avoid it?

How many generations does the .NET GC have and why?

What is the Large Object Heap, why does the runtime normally skip compacting it, and what does GCSettings.LargeObjectHeapCompactionMode control?

How do workstation and server garbage collection differ, and what roles do background and concurrent GC modes play?

Can you explain the generation-0 allocation fast path, how generation budgets trigger collections, and how survivor statistics adjust those budgets?

Why does pinning objects cause heap fragmentation, and what are fixed buffers with their associated risks?

Why does the GC.KeepAlive method exist, and in which finalizer or interop scenarios is calling it necessary?

When should you call GC.AddMemoryPressure, and why must every call be paired with GC.RemoveMemoryPressure?

How do lambda closures and delegate creation produce hidden heap allocations, and when does the runtime manage to avoid them?

When does choosing a struct instead of a class reduce garbage-collection pressure, and what hidden allocation costs can value types introduce?

What does the two-word object header of a .NET reference type consist of, and how does it relate to minimum object size?

What kinds of GCHandle exist, and when are pinned or weak-table handles the right choice?

How does stackalloc combined with Span<T> enable allocation-free temporary buffers, and what restrictions apply to using it?

Why does an async method tend to allocate on every await, and how do ValueTask and pooling reduce that overhead?

What is string interning, and why can the intern pool act like a one-way memory leak for dynamic strings?

Which tools monitor .NET managed memory in production, and how do you connect counters to garbage-collection behavior?

What is functional programming and how does C# support it?

What is a pure function and why do you prefer them?

What is a higher-order function in C#?

What are records in C# and how do they help with immutable data?

What is the difference between LINQ deferred execution and immediate execution?

What is a monad in functional terms and how does Task relate to it?

What does deferred execution mean for LINQ queries, and when should you call ToList or ToArray to materialize results?

Why is Expression<Func<T, bool>> more powerful than Func<T, bool>, and how do providers like EF Core use expression trees?

What makes a function pure, and why do pure functions improve testability and reliability?

How do records, readonly structs, and the immutable collections library express immutability in C#, and what trade-offs do they impose?

What is fluent chaining in C#, and when does method-chaining style improve or hurt code readability?

What do switch expressions and positional or relational patterns add over a classic switch statement?

With no built-in pipe operator, how do you compose functions and build pipelines in C#?

What does SelectMany do with nested sequences, and when does it act as C#'s equivalent of a functional flatMap?

What does LINQ's Aggregate method do, and how does it relate to the functional fold or reduce pattern?

What does Enumerable.Zip do, which overloads exist in modern .NET, and when is it useful?

Why should you avoid side effects inside LINQ lambdas, and how does deferred execution amplify the risk?

How do you implement memoization for an expensive pure function in C#, and what correctness pitfalls arise?

How do Option and Result types express missing values or failures in C#, and why do they stay non-idiomatic in many codebases?

What are expression-bodied members, and which C# versions introduced support for each member kind?

What is a delegate in C# and why do you need them?

What is the difference between a delegate and an event?

What is the difference between Func, Action and Predicate delegates?

What is a multicast delegate and when would you use one?

What is the difference between an anonymous method and a lambda expression?

How do you define and consume a standard event following the EventArgs convention?

What are the differences between Func, Action, and Predicate delegates, and which one should you choose for a boolean test?

How do covariance and contravariance apply to C# delegates, and what do they permit when matching method signatures to delegate types?

What is an event leak, and why can a long-lived publisher keep short-lived subscribers alive forever?

Why would you implement custom add and remove event accessors, and what restrictions apply to readonly or custom-accessor events?

Why is raising an event not thread-safe, and how does copying to a local with atomic delegate updates make the raise pattern safe?

What happens when an event subscriber throws during a multicast invocation, and how do you ensure remaining handlers still run?

Why are async void event handlers dangerous, and how should async event handlers be structured instead?

Why do delegates invoke more slowly than direct method calls, and what specific costs do multicast, DynamicInvoke, and per-call lambda creation add?

What is a method group conversion, and how does the compiler resolve overloads and capture receivers when converting to a delegate?

Besides WPF's WeakEventManager, what techniques implement weak events so long-lived publishers stop keeping subscribers alive?

In what order does a multicast event invoke its subscribers, and should production code ever depend on that order?

What bug occurs when closures capture a for-loop variable, and why was foreach behaviour fixed in C# 5?

Is the `?.Invoke(...)` pattern a fully thread-safe event raise, and what races still lurk even with the compiler's snapshot logic?

Can C# delegates use ref and out parameters, and what restrictions apply to lambdas, expression trees, and async methods?

What is the difference between Dictionary<K,V> and HashSet<T>?

What are common LINQ pitfalls and how do you avoid them?

How do you safely iterate a collection while modifying it?

When would you use a List<T> vs an array?

What is the difference between First/FirstOrDefault and Single/SingleOrDefault in LINQ?

What is the difference between IEnumerable and IQueryable in C#?

What is the difference between Select and SelectMany?

When would you use a Queue T or a Stack T instead of a List T?

When should you choose SortedDictionary, SortedSet, or OrderedDictionary over a plain Dictionary or HashSet?

Why does exposing IReadOnlyList<T> not guarantee immutability, and how can you provide an actually safe read-only surface?

How do capacity, load factor, and hash collisions determine Dictionary<TKey,TValue> performance, and when is pre-sizing worthwhile?

Why is LinkedList<T> rarely a performance win over List<T>, and what would a proper deque add?

How do GroupBy, ToLookup, and ToDictionary differ in eagerness and duplicate handling, and how do you choose between them?

How does LINQ to Objects differ from IQueryable-based LINQ, and why does EF Core throw instead of silently translating local code?

What new LINQ methods did .NET 6 and .NET 9 add, and what do DistinctBy, Chunk, and KeyBy do?

Why do struct enumerators such as List<T>.Enumerator avoid boxing, and what happens when LINQ or interface typing forces boxing anyway?

When should you supply a custom IEqualityComparer<T>, and what invariants must it honour to keep collections correct?

How do ReadOnlyCollection<T>, ImmutableArray<T>, and ImmutableList<T> differ as read-only collection surfaces?

How does Lazy<T> implement thread-safe lazy initialization, and when is it preferable to eager or static initialization?

What gotchas does deferred LINQ enumeration create, and how do you pin down exactly when code runs?

What is defensive copying, and when should collections be copied before returning them to or accepting them from callers?

Is LINQ's OrderBy a stable sort, and how does stability relate to multi-key ordering with ThenBy?

What is the difference between an array and a linked list?

What is a hash table and how does the C# Dictionary work internally?

What is the difference between a Stack and a Queue?

What is a binary search tree and why does it degrade to O(n)?

What is a priority queue and how do you implement it in C#?

When would you use a HashSet instead of a List in C#?

What is a trie and when is it a better choice than a hash map?

What are the time and space complexities of common graph representations?

How do AVL and Red-Black trees self-balance, and what role do rotations and recolorings play?

How does a trie store strings, and what are its time and space complexities?

How do chaining and open addressing differ as hash collision resolution strategies?

Why is repeated appending to a dynamic array O(1) amortized even though one resize is O(n)?

What are practical use cases for a deque and for a priority queue?

How does a skip list achieve its expected complexity, and what space does it use?

How does a bloom filter work, and how do its size and hash count affect the false-positive rate?

How do prefix sums, Fenwick trees, and segment trees compare for range-query problems?

How would you design an LRU cache giving O(1) get and put using a hash map and a linked list?

What are the trade-offs between adjacency list and adjacency matrix graph representations?

How can you model a weighted graph in C# using nested dictionaries?

How does union-find work, and what do path compression and union by rank achieve?

What are the typical big-O time complexities of array, linked list, BST, and hash table operations?

What is a circular buffer, how is it implemented, and where is it used?

What is Big O notation and why does it matter?

What is binary search and what are its prerequisites?

What is the difference between a stable and an unstable sort?

Compare the time complexity of bubble, merge and quick sort.

What is dynamic programming and when do you reach for it?

What is a greedy algorithm and when does it give the optimal answer?

What is Dijkstra's algorithm and what is its time complexity?

What is the difference between breadth-first and depth-first search?

What is the space-time tradeoff, and when do you choose storing more data over recomputing it?

What does the master theorem state, and how do you apply it to typical divide-and-conquer recurrences?

How do quicksort, mergesort, and heapsort compare on stability, in-place sorting, and worst-case time?

How do counting sort, radix sort, and bucket sort work, and when should you choose them over comparison sorts?

What are the two-pointer and sliding-window patterns, and when does each apply?

When is a greedy strategy wrong, when does dynamic programming apply, and what is memoization?

How do you formulate dynamic programming for the 0/1 knapsack, LCS, and longest increasing subsequence problems?

What is topological sort, and how do you detect a cycle while running it?

When should Dijkstra, Bellman-Ford, or Floyd-Warshall be chosen, and how do they compare?

What is the difference between BFS and DFS traversal order on graphs and trees?

How does backtracking work with state restoration and pruning in constraint-based search?

How do KMP and Rabin-Karp string matching work, and what are their complexities?

How do hash maps commonly turn an O(n^2) scan into an O(n) or O(n log n) solution?

What is amortized complexity, and how does it contrast with average-case analysis?

What process do you follow to choose a data structure given a problem's constraints?

What is your step-by-step approach to solving an algorithmic problem in a whiteboard interview?

What is the difference between throw and throw ex in exception handling?

When should you create a custom exception class in C#?

What is the finally block and when is it guaranteed to run?

What are exception filters and when are they useful?

How should you handle exceptions at the boundaries of an ASP.NET Core application?

What is the difference between an exception and an error in .NET?

Is code in a finally block guaranteed to execute, and under what circumstances can it be skipped?

What are catch filters in C#, and why are they a better alternative to catching and re-throwing conditionally?

What is the difference between throw and throw ex inside a catch block?

Why does Task.WhenAll surface multiple failures as an AggregateException, and how should it be flattened?

What is exception wrapping, how does InnerException fit in, and when should you wrap instead of rethrowing?

What should a custom exception type include, and how should the Data collection be used?

Why should catch blocks target specific exception types instead of catching the base Exception class?

How do exceptions flow through async/await, and why can a stream be disposed too early when a Task wraps an async read?

What is ExceptionDispatchInfo and when does capturing and rethrowing it make sense?

What is the TryParse/Result pattern, and how does it compare to throwing exceptions for expected failures?

What is Debug.Assert, when should it be used, and how does it differ from throwing exceptions?

Why cannot OutOfMemoryException and StackOverflowException be reliably caught, and how should they be handled?

What is the performance story behind exception filters, and do they really make exception handling faster?

What does exception safety mean for collections and transactions, and how do you make mutations atomic?

How does async/await work in C# and what are common mistakes?

What is the difference between Task.Run and async/await?

What is a deadlock in multithreaded C# and how do you avoid it?

What is the difference between lock, Monitor and SemaphoreSlim?

What is the difference between Task, Task T and ValueTask T?

How does CancellationToken support cooperative cancellation in C#?

How is a continuation after an await scheduled when a synchronization context is present versus absent?

How can missing ConfigureAwait(false) cause deadlocks in UI and classic ASP.NET applications?

Why is async void dangerous except in event handlers?

When should a method return ValueTask instead of Task?

What is the difference between using Task.WhenAll and awaiting tasks one after another?

How does cooperative cancellation work with CancellationToken and CancellationTokenSource?

When should you use lock/Monitor, SemaphoreSlim, or Interlocked for synchronizing shared state?

What differentiates reentrant locks from rendezvous or barrier synchronizations?

What are IAsyncEnumerable and await foreach, and what backpressure do they provide?

How do lock-free data structures work, and how does LazyInitializer differ from Lazy<T>?

Why can blocking inside asynchronous code cause thread-pool starvation?

How do you handle CPU-bound work differently from I/O-bound work in .NET?

What happens to exceptions thrown in fire-and-forget tasks and how do you avoid silent failures?

How do you safely update the UI from a timer callback, and when would you choose TPL Dataflow for a pipeline?

What is the difference between a process and a thread?

What is a context switch and why is it expensive?

What is deadlock and what conditions cause it?

What is the difference between preemptive and non-preemptive scheduling?

What is a thread pool and why does .NET use one?

What is the difference between concurrency and parallelism?

What is the producer-consumer problem and how do you solve it in .NET?

What is a race condition and how does the CLR help you avoid them?

What is the lifetime of a process, and what data does the process control block store?

How do round-robin, priority, and preemptive scheduling policies compare in trade-offs?

How do mutex, semaphore, and condition variable compare at the operating-system level?

What differentiates interrupts from exceptions, and how does the operating system handle each?

Why does the split between user mode and kernel mode exist, and how do system calls enter the kernel?

How does virtual memory work with multi-level paging and TLBs, and what is the page-fault path?

What is thrashing, and what does the working-set model tell us about it?

What are inodes, internal and external fragmentation, and journaling in file systems?

How do pipes, message queues, and shared memory compare as IPC mechanisms, and what are their trade-offs?

When would you use sockets instead of pipes for inter-process communication?

What are file descriptors, and why do processes need resource limits around them?

How do fork and exec work, and why does copy-on-write make fork practical?

How do kernel-level threads and user-level threads differ, and how do they map to cores?

What is the CPU cache hierarchy, and why does locality of reference matter?

How do scheduling policies cause starvation, and what does starvation-free scheduling require?

Why do race conditions occur at the machine level, and what does a read-modify-write imply?

What is the difference between TCP and UDP?

What is the three-way handshake in TCP?

What is DNS and how does domain resolution work?

What is the difference between HTTP/1.1, HTTP/2 and HTTP/3?

What is a reverse proxy and how is it different from a forward proxy?

How do you make HTTP calls robustly in .NET?

What is the OSI model and which layers matter for .NET developers?

When do you pick TCP vs UDP for a real API?

How does the TCP three-way handshake establish a connection, and what are the main connection states?

What are the main differences between the TLS 1.2 and TLS 1.3 handshakes, and how are certificates used in both?

How do HTTP/1.1, HTTP/2, and HTTP/3 differ in multiplexing, headers, and transport?

What are the steps of DNS resolution, and when does DNS use TCP instead of UDP?

How do connection pooling and keep-alive reuse HTTP connections, and what does HTTP/2 multiplexing add?

What is the purpose of the Expect: 100-continue header, and how is it used?

What does NAT do, and why can UDP hole punching enable peer-to-peer communication through it?

What is the difference between Layer 4 and Layer 7 load balancing, and when would you use each?

Why do retries and backoff improve HTTP reliability, and how does idempotency relate to retrying POST requests?

How does TCP handle packet loss and congestion, and what is window scaling?

How do WebSockets, Server-Sent Events, and HTTP polling compare for delivering real-time data?

How do Cache-Control and ETag headers implement HTTP caching, and what revalidation strategies exist?

What is middleware in ASP.NET Core and how does the pipeline work?

How does dependency injection work in ASP.NET Core?

What is the difference between AddSingleton, AddScoped and AddTransient in dependency injection?

How does authentication and authorization work in ASP.NET Core?

What is the difference between Minimal APIs and Controllers in ASP.NET Core?

How does configuration work in ASP.NET Core and where do secrets live?

What is Kestrel and how does logging work in ASP.NET Core?

What is model validation in ASP.NET Core and how do you add rules?

What is model binding and what do FromBody, FromQuery and FromRoute do?

What determines the order of middleware in the ASP.NET Core request pipeline, and how can a middleware short-circuit the pipeline?

What are the caveats and scoping concerns when using IHttpContextAccessor in ASP.NET Core?

How do configuration providers aggregate settings in ASP.NET Core, and how is the options pattern used with validation?

How does ASP.NET Core load environment-specific configuration for Development, Staging, and Production?

How does the logging stack work in ASP.NET Core, and what is structured logging with Serilog?

When should you use filters instead of middleware in ASP.NET Core, and what distinguishes authorization and exception filters?

How do you create a custom ViewComponent or custom tag helper in ASP.NET Core, and when is each preferred?

How do health checks work in ASP.NET Core, and what is the difference between liveness and readiness probes?

How does rate limiting work in ASP.NET Core, and what algorithm options are available?

What are the differences between response caching and output caching in ASP.NET Core?

How does SignalR manage connections and hub lifetimes, and how do you send messages from outside a hub?

When should you choose gRPC over REST in a .NET service, and what are the trade-offs?

What are the key differences between minimal APIs and controller-based APIs in ASP.NET Core?

How does IHostApplicationLifetime expose application lifecycle events, and how is it used in ASP.NET Core?

How do you implement background tasks with IHostedService and BackgroundService in ASP.NET Core?

What is the difference between conventional routing and attribute routing?

What is the request lifecycle in an ASP.NET Core MVC application?

What is the difference between MVC and Web API in ASP.NET Core?

What are the common IActionResult types in an ASP.NET Core controller?

What is content negotiation in Web API and how does it choose JSON or XML?

What are filter attributes and in what order do filters execute in ASP.NET Core?

How does model binding handle complex types in ASP.NET Core, and what is the difference between binding from the form and from the body?

What do the [FromServices], [FromRoute], and [FromQuery] binding attributes control in ASP.NET Core Web API?

How do you implement request validation with DataAnnotations and with FluentValidation in ASP.NET Core Web API?

How do you implement a custom model binder in ASP.NET Core using IModelBinder, and when is it necessary?

What is the difference between returning an action result and returning ActionResult&lt;T&gt; in ASP.NET Core Web API?

How does content negotiation work in ASP.NET Core Web API, and what role do formatters play?

In a Web API, when should you return a status code instead of throwing an exception?

How do you implement a global exception handler in ASP.NET Core that returns ProblemDetails?

How do you add API versioning in ASP.NET Core, and what strategies are available?

What are the common conventions for paginating a Web API, and what metadata should be returned?

How do you generate links and absolute URLs in ASP.NET Core using UrlHelper and LinkGenerator?

How does anti-forgery (CSRF) protection work in ASP.NET Core for form posts and for AJAX/API calls, and when is it needed?

How do you configure CORS with credentials in ASP.NET Core, and why is it disallowed with wildcard origins?

How does API Explorer enable OpenAPI/Swagger generation in ASP.NET Core?

What is WCF and what is it used for?

What are the common WCF bindings and when do you use each?

What are the differences between WCF and ASP.NET Core Web API?

What are the practical differences between net.tcp, basicHttp, wsHttp, and namedPipes bindings in WCF?

How do duplex contracts and callbacks work in WCF, and which bindings support them?

What are the roles of service contracts, data contracts, and message contracts in WCF?

How are typed faults modeled in WCF with fault contracts and FaultException&lt;T&gt;?

How does WCF support transactions with NetTcpBinding and TransactionScope, and what is required?

What is the difference between transport-level and message-level security in WCF, and how are certificates involved?

What are the options for hosting a WCF service, and what is the ServiceHost lifecycle?

What is the difference between eager loading and lazy loading in Entity Framework Core?

What are database migrations in EF Core and when should you use them?

What is the difference between code-first and database-first development?

What does AsNoTracking do and when should you use it?

How do you run raw SQL with EF Core without opening a SQL-injection hole?

What is the difference between Include and ThenInclude in EF Core?

Why should a DbContext be short-lived and how is it scoped in ASP.NET Core?

What are the async EF Core methods and why prefer them?

When should you use AsNoTracking() in an EF Core query, and what role does identity resolution play when entities are tracked?

What entity states does the EF Core change tracker use, and why does DetectChanges matter for correctness and performance?

How does EF Core batch the commands SaveChanges generates, and what atomicity guarantees does the surrounding transaction provide?

What is connection resiliency in EF Core, and when should you enable retry on failure for SQL Server?

Why can joining multiple collection navigations in one EF Core query cause a cartesian explosion, and how does AsSplitQuery help?

How do you run raw SQL safely in EF Core, and what differentiates FromSqlInterpolated from FromSqlRaw?

What do ExecuteUpdate and ExecuteDelete do in EF Core 7, and when are they better than a loop of tracked changes?

How do owned types and value converters change the way EF Core maps complex values, and what are the limits of each?

What are shadow properties in EF Core, and in which scenarios would you use one?

What are the differences between eager, lazy, and explicit loading in EF Core, and what rules govern their use?

How do global query filters work in EF Core, and what are the common gotchas when you add them?

What is a keyless entity type in EF Core, and when should you map a database view to one?

Why should a DbContext live only for a short unit of work, and what does AddDbContextPool change about its lifetime?

How does a rowversion concurrency token protect concurrent updates, and what happens when two writers collide?

What are the safe ways to apply EF Core migrations in production, and what mistakes should you avoid?

Which performance pitfalls do client-side evaluation, N+1 queries, and the TPH versus TPT inheritance choice cause, and how do compiled queries help?

What are the key objects in the ADO.NET architecture?

What is the difference between SqlDataReader and DataSet?

What is connection pooling in ADO.NET and why does it matter?

What is the difference between CommandType.Text and CommandType.StoredProcedure?

When is a SqlDataReader a better choice than filling a DataTable or DataSet, and what are the trade-offs?

How does SqlParameter prevent SQL injection, and why is string concatenation into a SqlCommand so dangerous?

What do ExecuteScalar, ExecuteNonQuery, and ExecuteReader each return, and when do you choose each one?

What do CommandTimeout and the Pooling, Max Pool Size, and Connection Timeout settings in a connection string control?

What is MARS (Multiple Active Result Sets) in SqlClient, and when does it help or hurt a design?

How does async with SqlClient and EF Core improve server scalability, and what are the pitfalls?

What is the semantic difference between READ COMMITTED and SNAPSHOT isolation in SQL Server, and where does the version store come in?

How does SqlBulkCopy achieve high insert throughput, and what do BatchSize and UseInternalTransaction control?

What is the difference between typed and untyped DataSets, and what roles do DataAdapter Fill and Update play?

How can you retrieve table or result-set schema with ADO.NET, and why should metadata retrieval happen once?

Why are using blocks mandated around ADO.NET objects, and what order should you dispose them in?

If ADO.NET gives full control, why do most modern teams still wrap it with EF Core or Dapper?

What is the difference between a clustered and a non-clustered index?

What is the difference between a primary key and a unique key?

What is ACID and why does it matter for transactions?

What makes a WHERE clause sargable and why does it affect performance?

What is the N+1 query problem and how do you avoid it?

What is the difference between a view and a stored procedure?

What distinguishes a clustered index from a nonclustered index, and what makes an index covering?

What is the difference between an index seek, an index scan, and a key or RID lookup in a SQL Server plan?

How does SQL Server use statistics and cardinality estimation to build plans, and what is the problem with statistics on temp tables?

What causes deadlocks in SQL Server, and what does lock granularity have to do with them?

What is the difference between READ COMMITTED and READ COMMITTED SNAPSHOT in SQL Server, and what does each guarantee?

Why does every SQL Server need tempdb, and what roles do its files and the version store play?

What is parameter sniffing, why can it produce bad plans, and how do Query Store or plan guides mitigate it?

What do the nested loops, merge, and hash join operators in an execution plan actually do, and when does the optimizer pick each?

How do DDL triggers differ from DML triggers, and when should constraints be used instead of triggers?

How does SQL Server table partitioning work, and what does partition elimination do for queries?

When should you use a query hint, a plan guide, or Query Store plan forcing instead of rewriting the query?

Why does BULK INSERT with TABLOCK load data so much faster, and when is the load minimally logged?

What does DBCC CHECKDB verify, and why should production databases run it regularly?

What is the difference between rebuilding and reorganizing an index, and how do you decide between them?

What is a primary key and what is a foreign key in SQL?

What is an index and why do queries use them?

What is the difference between INNER JOIN and LEFT JOIN?

What are the ACID properties of a database transaction?

What is normalization and what do the first three normal forms mean?

What is an execution plan and how do you use it to tune a slow query?

What is an SQL transaction and how does EF Core handle them?

What is connection pooling and why does it matter for .NET apps?

How do LEFT, RIGHT, and FULL outer joins differ from inner joins, and can join order hurt performance?

When would you prefer a scalar or derived subquery, a CTE, or a lateral APPLY join for the same logical need?

How do window functions such as ROW_NUMBER, RANK, LAG, and SUM OVER work, and what problems do they solve?

What do ROLLUP, CUBE, and GROUPING SETS add beyond a plain GROUP BY, and what does the GROUPING() function do?

What is the difference between UNION and UNION ALL, and why is UNION ALL usually cheaper?

How does a correlated subquery evaluate, and why is EXISTS often the better tool for such checks?

What NULL pitfalls should a query author watch for with COALESCE and ISNULL?

How do the percentage and underscore wildcards behave in LIKE, and how do you search for a literal wildcard?

How does a recursive CTE execute, and what controls how deeply it can recurse?

How does the MERGE statement implement an upsert, and what are its known footguns?

Why does a view sometimes run slowly even when it looks simple, and what does materializing a view mean?

Why can two queries in one transaction still observe inconsistent data, and which isolation levels fix that?

Why does OFFSET/FETCH pagination get slower on deep pages, and how does keyset pagination fix it?

What exactly does parameterization do to stop SQL injection, and what complements it?

What are the main categories of NoSQL databases?

What is the CAP theorem and how do databases choose?

When would you use MongoDB instead of SQL Server?

What is eventual consistency and when is it acceptable?

What is Redis and what data structures does it offer?

How do you choose between a relational and a graph database?

How do you model relationships in a document database like MongoDB, and when do you embed instead of referencing documents?

How do Redis eviction policies, TTL expiration, and its RDB/AOF persistence modes work together?

How does a wide-column store like Cassandra partition data, and what consistency levels can a query request?

Why are graph databases like Neo4j faster than relational joins for deeply connected data such as social graphs?

How does the CAP theorem apply in practice to Cassandra, MongoDB, and Redis during a network partition?

What are the trade-offs between sharding and replication when scaling a distributed data store?

What is eventual consistency, and how does the read-your-writes guarantee make distributed reads feel truly consistent to one client?

Why do NoSQL data models encourage denormalization, and where should you stop duplicating data?

What hidden maintenance cost does the schema-less nature of a document database impose on evolving applications?

Why can NoSQL databases not always match relational ACID for multi-operation transactions, and when does it matter?

What makes a time-series database different from a generic NoSQL store for metrics, IoT, and log-like workloads?

How do cache-aside and write-through caching differ, and when should a cache like Redis be treated as the source of truth?

How do you collect and debug slow queries in NoSQL stores such as MongoDB, Cassandra, and Redis?

How do you choose between SQL and NoSQL, and how does read-heavy versus write-heavy access influence that decision?

Explain SOLID principles with a C# example.

When would you use the Strategy pattern in C#?

What are design patterns and what are the three GoF categories?

How do you write a thread-safe Singleton in modern C#?

What is the difference between Factory Method and Abstract Factory?

What is the difference between IoC, DI and the Dependency Inversion Principle?

How do you apply the Open/Closed Principle in practice beyond inheritance, and why is inheritance-based extension often a trap?

What is the Dependency Inversion Principle, and how does a composition root wire dependencies together in a .NET application?

Can you give real C# examples of Liskov subtype violations, such as the Rectangle/Square problem, and explain what makes them invalid?

What is the Interface Segregation Principle, and what symptoms indicate a C# interface is too fat?

How do the Strategy and State patterns differ, and when would you use each with a small C# example?

What problem does the Command pattern solve, and how does it enable undoable, queued operations in C#?

When do you use the Decorator pattern in C#, and how does it differ from subclassing for adding responsibilities?

What is the Template Method pattern, and how does it let base classes reuse an algorithm while subclasses vary the steps?

What are the Facade and Adapter patterns, and how do they differ when wrapping a third-party or legacy API in C#?

What are the Builder and Prototype patterns, and when is each the right tool for constructing complex objects in C#?

How do the Mediator, Memento, and Visitor patterns compare, and what are their most common C# use cases?

What are the God object, Anemic domain model, and Service Locator anti-patterns, and how do you avoid each?

What do transient, scoped, and singleton lifetimes mean in a .NET DI container, and what common bugs result from misusing them?

How do Domain Events, CQRS, and DDD aggregates define module boundaries, and how does hexagonal architecture compare with a layered one?

What is the difference between monolithic and microservices architecture?

What are the trade-offs of a layered architecture?

What is CQRS and when should you use it?

What is event sourcing and what are its benefits and costs?

What is the difference between horizontal and vertical scaling?

How does the API gateway pattern work in microservices?

What is a service mesh and when would you use one?

What is the difference between SOA and microservices?

How do you decompose a monolith into microservices by bounded context, and what shapes the service boundaries?

Compare choreographed and orchestrated sagas for distributed transactions, and when would you pick each?

What is the transactional outbox pattern, and how does it make message publishing reliable in an event-driven system?

How do idempotency keys and retry logic make distributed API calls safe against duplicate processing?

How do message queues like SQS differ from pub/sub brokers like Kafka and RabbitMQ's publish/subscribe mode?

What is backpressure and how does it differ from throttling in a streaming or messaging pipeline?

How does the token bucket algorithm work for rate limiting, and what are its alternatives in distributed systems?

Why do microservices need graceful shutdown and health checks, and how do liveness and readiness probes differ?

How do DNS caching and CDNs combine to reduce latency, and what role do TTLs play in each layer?

What are SLIs, SLOs, and error budgets, and how should an SRE team use them to balance reliability with feature velocity?

What do logs, metrics, and traces each provide for observability, and how do correlation IDs connect them?

How do circuit breakers and bulkheads isolate failures and prevent cascading outages in a microservice system?

How do you manage configuration, secrets, and feature flags across environments in a microservice platform?

What are the basics of capacity planning for a .NET web service, and how do you turn load tests into node counts and budgets?

What challenges appear when two microservices need a shared transaction?

What is the outbox pattern and why does it exist?

What is idempotency and how do you design idempotent APIs?

What is a distributed lock and when do you need one in .NET?

What is the difference between a message queue and a publish-subscribe system?

What is the saga pattern and what are its two main implementations?

What is the circuit breaker pattern and how does it differ from retries?

What is consistent hashing and why is it used in distributed caches?

What distinguishes strong, linearizable, and eventual consistency, and how do quorum read/write sizes affect them?

What is the intuition behind leader election and consensus algorithms like Raft and Paxos, and where are they used?

How do synchronous and asynchronous replication compare, and what happens during replica failover?

How do hash-based and range-based sharding compare, and why is rebalancing a sharded cluster so complex?

How does two-phase commit differ from a saga, and when is each appropriate for distributed transactions?

How can a distributed cache become inconsistent with its database, and which invalidation strategies fix it?

Why are physical clocks unreliable for ordering in distributed systems, and what do logical clocks and vector clocks provide instead?

How do distributed locks work in practice, and why is the fencing token pattern critical to making them safe?

Why is exactly-once delivery impossible in general, and how do at-least-once delivery plus idempotency come close in practice?

What is distributed tracing across services, and how you can interpret a trace that spans many hops?

How do gossip protocols and membership services let nodes discover each other and detect failures without a central registry?

How is backpressure implemented in streaming systems, and what does it mean when a Kafka consumer group is "behind"?

How does the CAP theorem constrain real distributed systems, and how does it explain choosing between consistency and availability during partitions?

What causes split-brain in a replicated system, and what role does quorum size play in preventing two leaders from accepting writes?