C# & .NET Core Ecosystem Interview Preparation Guide

Task.Yield() is an asynchronous operation that immediately yields execution back to the current synchronization context or thread pool, forcing the remainder of the async method to resume asynchronously. It is commonly used in UI applications or long-running synchronous loops to keep the event loop responsive without introducing time delays. In contrast, Task.Delay() introduces a time-based delay by scheduling a timer on the thread pool timer queue, suspending execution for a specified duration before resuming. While Yield forces an immediate context switch if needed, Delay waits for a specific time interval to elapse.

Traditional object-oriented polymorphism relies on virtual method tables (vtables) where behavior is encapsulated inside the type itself through method overriding. C# pattern matching, introduced extensively in modern C# releases, allows external logic to inspect an object's type, properties, or structural shape without modifying the underlying class definition or requiring virtual dispatch. Pattern matching expressions, property patterns, and switch expressions provide declarative syntax that excels at evaluating disjoint data shapes, whereas traditional polymorphism is superior for encapsulating domain behaviors inside cohesive object models.

Garbage Collectors only reclaim memory that is unreachable from any root references. Memory leaks occur in .NET when managed objects remain inadvertently rooted, most commonly through static event subscriptions, unremoved event handlers, lingering background tasks holding references to service scopes, long-lived cache collections that grow unbounded, or static references. When references persist in static fields or long-lived singletons, the GC cannot promote or sweep those objects, leading to steady memory growth and eventual OutOfMemoryException crashes.

An application should choose Dapper over Entity Framework Core when maximum raw query performance and minimal memory allocation are paramount, such as in high-frequency trading engines, high-throughput log ingestion pipelines, or reporting endpoints querying millions of rows. Dapper is a micro-ORM that executes raw SQL with minimal abstraction overhead, bypassing change tracking, expression tree translation, and complex object graph materialization. EF Core, however, is preferred for rapid enterprise application development where LINQ type safety, automated migrations, and unit-of-work change tracking outweigh raw query speed.

Workstation GC is optimized for client applications, running on a single dedicated GC thread and minimizing memory footprints, which makes it ideal for containers with tight resource constraints. Server GC, by contrast, dedicates a separate heap and GC worker thread to each logical CPU core, maximizing throughput and parallelizing collection sweeps across multiple processors. High-throughput backend web servers and microservices deployed on multi-core cloud infrastructure almost always benefit from enabling Server GC, while memory-constrained serverless functions may prefer Workstation GC.

The Captive Dependency anti-pattern occurs when a service with a longer lifecycle (such as a Singleton) holds a reference to a service with a shorter lifecycle (such as a Scoped or Transient service) in its constructor. Because the Singleton lives for the entire application lifespan, it captures the Scoped service, forcing it to live indefinitely and sharing its state across independent HTTP requests. This leads to data corruption, concurrency bugs, and subtle memory leaks. ASP.NET Core development environments detect this during container validation if scope validation is enabled.

Span<T> is classified as a ref struct because it can wrap arbitrary contiguous memory regions, including unmanaged memory pointers and stack-allocated buffers. To guarantee memory safety and prevent invalid memory access, ref structs are strictly constrained to stack allocation. They cannot be boxed into object types, cannot be stored as fields in standard heap-allocated classes, cannot be used as generic type arguments, and cannot be captured in lambda expressions or async method state machines that cross await boundaries.

ASP.NET Core middleware operates at the global server level, processing every incoming HTTP request and outgoing response passing through the Kestrel pipeline, handling cross-cutting concerns like static files, routing, authentication, and global error handling. MVC action filters, conversely, operate specifically within the MVC framework execution pipeline after routing has resolved a target controller and action. Action filters have granular access to controller action arguments, model states, and action results, making them ideal for controller-specific authorization and model validation.

The Roslyn compiler (.NET Compiler Platform) exposes rich code analysis APIs, syntax trees, semantic models, and diagnostic analyzers directly to developers and IDEs. Beyond compiling C# source code into Common Intermediate Language bytecode, Roslyn powers real-time code refactoring, IDE IntelliSense, static code analysis rules, and C# Source Generators. Source generators leverage Roslyn to inspect code syntax trees during compilation and emit additional C# source files on the fly, eliminating runtime reflection overhead.

EF Core handles transient database connectivity failures by configuring execution strategies, such as `EnableRetryOnFailure()` in the SQL Server provider options. When enabled, EF Core intercepts transient exceptions (like temporary network drops or SQL Azure throttling) and automatically retries the operation using exponential backoff algorithms. This ensures that transient network hiccups do not crash incoming web requests or background database operations.

IOptions<T> provides singleton-scoped configuration options that are evaluated once at application startup and never change during the application lifecycle. IOptionsSnapshot<T> creates a new options instance per HTTP request, supporting scoped configuration reloading when underlying JSON files change. IOptionsMonitor<T> is a singleton service that monitors configuration changes in real time, exposing change notification events (OnChange) without requiring request-scoped boundaries.

Async void methods are designed exclusively for top-level event handlers where no caller awaits completion. When an async void method encounters an unhandled exception, that exception cannot be caught by a standard try-catch block in the calling method because there is no Task object returned to capture the execution state. Instead, the exception propagates directly to the synchronization context and crashes the entire application process. Developers should always return Task or Task<T> for all asynchronous methods.