C#/.NET Interview Mastery: Hands-On Edition (2026)

Wishlist

About Course

C#/.NET Interview Mastery: Hands-On Edition (2026)
Write code. Solve problems. Ace interviews.

Course summary

This course is a comprehensive, structured preparation program designed to help developers confidently tackle real-world C# and .NET interview questions — from fundamentals to advanced system design.

The course mirrors actual industry expectations and includes guided theory, runnable examples, quizzes, and assignments with complete solutions.

Ace your C# and .NET interviews with 100+ practical, production-oriented questions asked by the industry’s top companies. Each lesson breaks down complex concepts into digestible explanations, hands-on code samples, and interactive quizzes to reinforce mastery.

What’s included?

  • 100+ carefully curated interview questions with full answers
  • Step-by-step theory and executable examples
  • 1,200+ quiz questions (True/False, multiple choice, matching, fill-in-the-blank)
  • 200+ hands-on assignments (easy and advanced, with hints and full solutions)
  • Complete coverage of C# fundamentals, advanced topics, and the .NET ecosystem
  • Regular updates aligned with the latest .NET releases
  • Lifetime access and progress tracking
  • Certificate of Completion

What will you learn (or refresh your memory on)?

  • Core C# syntax, memory management, and type system (value vs reference)
  • Asynchronous programming, threading, and performance tuning
  • Reflection, generics, LINQ, and modern language features
  • Dependency Injection, configuration, and hosting in ASP.NET Core
  • Entity Framework Core, migrations, and data persistence patterns
  • Authentication, authorization, and security best practices
  • Testing, debugging, and performance profiling techniques
  • Modern deployment models: containers, Azure, and CI/CD pipelines
  • Design patterns, SOLID principles, and clean architecture in .NET

Course description

This course transforms the traditional interview prep experience into a hands-on learning journey. Each topic starts with a clear question, followed by a concise answer, theory with runnable C# examples, and a comprehensive quiz section to reinforce understanding. You’ll also complete two guided assignments per topic — one easy, one advanced — ensuring you can apply every concept in practical scenarios.

You’ll move from foundational knowledge — like memory allocation, boxing, and type safety — to advanced subjects such as async streams, dependency injection, EF Core optimization, and ASP.NET Core middleware pipelines. The final modules cover real-world architecture and design patterns, helping you confidently discuss and demonstrate system design decisions during interviews.

Whether you’re preparing for a junior developer, mid-level engineer, or senior architect role, this course gives you a structured path to master every critical C#/.NET interview area — theory, code, and practice combined.

Course Content

Introduction
Welcome to the Course

What is .NET CLI (and what can we do with it)?
What is the .NET CLI and how do you use it to create, build, run, test, package, publish, manage dependencies, tools, solutions, and workloads from the command line across platforms?

What is the CLR and how does .NET execute code?
What is the Common Language Runtime (CLR) and how does .NET execute code from source to IL to native (including assemblies, metadata, verification, JIT, tiered compilation, ReadyToRun/AOT, GC, exceptions, and interop)?

How do .NET Framework, .NET Core, and modern .NET differ?
How do .NET Framework, .NET Core, and modern .NET (.NET 5+) differ in platform support, app models, deployment, performance, APIs, and tooling—and how do you multi-target and port code safely between them?

What’s the difference between stack and heap memory?
What is the difference between stack and heap memory in .NET — who allocates and frees them, what typically lives where, how does lifetime and performance differ, and what are the key caveats such as boxing, closures, async state machines, and large objects?

What is Garbage Collector (GC) and how does it work?
What is the .NET Garbage Collector and how does it reclaim memory, including generations, LOH, ephemeral collections, finalization, and IDisposable, and when should you influence it with GC APIs for correctness and performance?

What are boxing and unboxing?
What are boxing and unboxing in C# — when does a value type get wrapped into an object (or interface) reference, what costs and pitfalls does that introduce, how do you avoid accidental boxing in hot paths, and how do you safely unbox back to the original value type?

Value Types vs Reference Types
What’s the difference between value types and reference types in C#, and why does it matter for correctness and performance?

When would you use a struct vs a class?
When should you choose a struct instead of a class in C#—considering semantics (value vs reference), size and immutability, copying costs, inheritance, boxing, interop, and performance trade-offs—and how do features like readonly struct, ref struct, and records influence that choice?

What is encapsulation?
What is encapsulation in C#, how do access modifiers, properties, and invariants help you hide representation, and why does it matter for correctness, maintainability, and testability?

What is polymorphism?
What is polymorphism in C#, how do inheritance, virtual/override, and interfaces enable it, and why does it matter for correctness, extensibility, and testability?

Interface vs Abstract Class – differences?
When should you use an interface vs an abstract class in C#, and why does it matter for design, testability, and versioning?

What is deferred vs immediate execution in LINQ?
When would you use LINQ in C#, and what does “deferred execution” mean (why does it matter for correctness and performance)?

How does async/await work?
How does async/await work in C#, and when should you use it? Why does it matter for correctness and performance?

What is IDisposable in .NET and when should you implement it?
What is IDisposable in .NET, when should you implement it, and how do using/await using ensure resources are released reliably? Why does this matter for correctness and performance?

What’s the difference between using statement and using declaration?
What is the difference between the traditional using statement and the newer using declaration in C# — how do their disposal timing, scope, and exception behavior differ, and when should you pick one over the other for clarity and safety?

How does Dependency Injection work in .NET?
What is Dependency Injection in .NET, when should you use it, and how do service lifetimes (Transient/Scoped/Singleton) affect correctness, testability, and performance?

When do we use, and how do we handle exceptions in C#?
How should exceptions be used in C# for correctness and clarity? When do you catch, rethrow, wrap, or avoid exceptions—and how do async, cancellation, and resource cleanup fit in?

Why is immutability useful and how to implement it?
Why is immutability valuable in C# for correctness, thread-safety, and reasoning, and what practical patterns (records, init-only setters, readonly struct, with expressions, defensive copies, and immutable collections) implement it effectively without killing performance?

Why are strings immutable and what is string interning?
Why are strings immutable in .NET, what benefits does immutability bring (correctness, thread-safety, security, caching), how does string interning reduce duplicate allocations via the intern pool, and when should you (not) use string.Intern and string.IsInterned?

When to use StringBuilder instead of string concatenation?
When should you choose StringBuilder over string concatenation, what are the performance and allocation tradeoffs, how do builder capacity and append patterns help avoid reallocations, and where is simple concatenation still the right choice?

What are different types of collections and what are generics?
How do you choose the right collection in C#, and what generic features (constraints, variance, comparers) matter for correctness and performance?

What are Span, ReadOnlySpan, and Memory?
What are Span/ReadOnlySpan and Memory/ReadOnlyMemory in C#, when should you use each, and why do they matter for safety and performance?

Threading & Synchronization
How do you write correct, performant multithreaded code in C#? When should you use Task/thread pool vs raw Thread, and how do primitives like lock, Interlocked, and SemaphoreSlim prevent races and deadlocks?

What are Delegates in C#? (Func, Action)
What are delegates in C#, how do Action and Func work, and when should you prefer them over custom delegate types?

What is Publisher/Subscriber pattern and when do we use it?
How do delegates and events enable the publisher/subscriber pattern in C#, and how do you correctly integrate async/await with them (including Func/custom async event handlers) to avoid fire-and-forget pitfalls?

What is serialization and deserialization?
How do you serialize and deserialize objects in C# using System.Text.Json? What knobs (options, attributes, converters) matter for compatibility, performance, and correctness, and how do you handle enums, dates, and custom types?

IEnumerable vs IQueryable — what’s the difference?
What is the difference between IEnumerable and IQueryable in C# — where does the work execute, how are operations represented (delegates vs expression trees), when are queries evaluated, and how do you choose between them for correctness and performance?

What is IAsyncEnumerable and when to use async streams?
What is IAsyncEnumerable, how do async iterators work with await foreach, what are the benefits (streaming, latency hiding, backpressure-friendly), and when should you prefer it over returning Task<List> or IEnumerable?

What is Array and how does it work under the hood?
What is an Array in C#, how does it work under the hood (contiguous memory, zero-based indexing, fixed length), and when should you prefer it over collections for performance and correctness?

What is Dictionary and how does it work under the hood?
What is a Dictionary in C#, how does it work under the hood (hashing & equality), and how do you use it correctly for performance and correctness (capacity, lookups, custom comparers, custom key types, and thread-safety)?

What is List and how does it work internally?
What is List in C#, how does it work internally (contiguous array + resizing), and how should you use it correctly (capacity, indexing, inserts/removes, enumeration, copying, performance and pitfalls)?

What is Queue and how does it work?
What is a Queue in C#, how does it work (FIFO with a circular buffer), and how should you use it correctly (enqueue/dequeue/peek, try-methods, capacity, enumeration, and thread-safe alternatives)?

What is Stack and how does it work?
What is a Stack in C#, how does it work (LIFO on a resizable array), and how should you use it correctly (push/pop/peek, enumeration order, capacity/perf, and thread-safe alternatives)?

What are concurrent collections and when to use them?
What are .NET’s concurrent collections (e.g., ConcurrentDictionary, ConcurrentQueue, ConcurrentStack, ConcurrentBag, BlockingCollection) and when should you pick each for multi-threaded producer/consumer, caching, and aggregation scenarios?

When should you use a record struct vs a record class?
What are records and record structs in C#, how do they differ from classes and structs in terms of value-based equality, immutability patterns, inheritance, and copying with with, and when should you choose each?

What is pattern matching?
What is pattern matching in C#, how does it unify type tests, shape checks, and conditions into concise is and switch constructs, and how do you use type, property, positional, relational, logical, and list patterns correctly for clarity and performance?

What are attributes in C#?
What are attributes in C#, how do they attach metadata to program elements to influence tools and runtime behavior, and how do you declare, apply, and read them correctly (targets, positional vs named arguments, AttributeUsage, inheritance, and reflection)?

What are nullable reference types and how do you enable them?
What are nullable reference types in C#? Flow analysis, annotations, and attributes work to prevent null-reference bugs—and how do you enable, interpret, and fix the compiler’s nullability warnings in real code?

When to use Parallel.ForEach vs PLINQ?
When should you prefer Parallel.ForEach over PLINQ (and vice versa) for data parallelism in .NET — considering work granularity, ordering, query-style composition, cancellation, exceptions, and I/O vs CPU workloads?

How do lock, Monitor, Mutex, and SemaphoreSlim differ?
How do lock, Monitor, Mutex, and SemaphoreSlim compare in scope, capabilities, and typical use—what’s in-process vs cross-process, which supports timeouts and async waiting, and how do you choose the right primitive for correctness and throughput?

What are covariance and contravariance?
In C# generics, what do covariance and contravariance mean, why do some generic interfaces and delegates declare out or in on their type parameters?

How do events work in C#?
What are events in C#—how do they relate to delegates, what patterns ensure thread-safe raising and unsubscription, and when should you use EventHandler versus custom delegates?

What are lambdas and expression trees?
What are lambdas in C# and how do expression trees differ from delegate lambdas?

What are source generators and typical use cases?
What are C# source generators and incremental generators—how do they plug into the Roslyn compiler pipeline, when should you use them to generate code (e.g., DI registration, INotifyPropertyChanged, strongly typed accessors, serializers), and how do you structure a solution so the generator project feeds generated code into a consumer project safely and performantly?

What is the dynamic keyword and DLR?
What does the C# dynamic keyword do at compile time and runtime, how does the Dynamic Language Runtime (DLR) bind and cache calls, and when is dynamic appropriate (e.g., COM/Office interop, JSON/Expando, scripting bridges) versus harmful for correctness and performance?

How do properties, indexers, and init-only setters work?
How do C# properties and indexers encapsulate state and expose controlled access, what can init-only setters guarantee at construction time, and how do you combine them (e.g., validation, computed members, accessor accessibility, ranges) to write safe, maintainable APIs?

How do you implement operator overloading?
How does C# support operator overloading for user types, which operators can be overloaded, what rules apply (static methods, pairs like </>, ==/!=), and how do you combine it with IEquatable<T>, IComparable, and user-defined conversions to build safe, intuitive value types?

What are iterators and yield return?
What are C# iterators and how do yield return/yield break work under the hood to create lazy sequences, what are the rules and limitations (state machine, deferred execution, disposal), and when should you prefer custom iterators over prebuilt LINQ operators for clarity and performance?

How do extension methods work and when to use them?
What are extension methods in C#, how do you declare and consume them (syntax, this parameter, visibility via using), what are the rules and pitfalls (static container class, resolution precedence, generics/constraints, null-handling), and when are they appropriate versus adding members or helper utilities?

What are partial classes and partial methods?
What are C# partial classes and partial methods, how do they let you split a type across files and inject optional hooks, what rules apply (same namespace/type/generics/base type, compile-time merge, visibility and return rules for partial methods), and when are they useful (code generation, designer files, source generators)?

What are top-level statements and global usings?
What are top-level statements and global usings in modern C#, how do they simplify program startup and imports, what are the scoping and compilation rules (single entry file, generated Program class, order constraints), and when should you use them versus a traditional Program.Main and per-file using directives?

What are primary constructors in C#?
What are primary constructors in modern C#, how do they differ from record primary constructors, how do you expose parameters as fields/properties, validate input, and use them with inheritance and dependency injection, and when are they preferable to traditional constructors?

What are nameof, var, and target-typed new?
What do nameof, var, and target-typed new do in C#, how do they improve maintainability and readability, what are their rules and pitfalls (compile-time name resolution, static type vs inferred type, when a target type is required), and when should you use or avoid them?

When and how would you use unsafe code and pointers?
When does unsafe code in C# make sense, what are the key building blocks (pointer types, &, *, ->, fixed, stackalloc, Buffer.MemoryCopy), what rules and risks apply (no bounds checks, GC pinning, unverifiable IL), and how do you combine them with safe abstractions like Span/ReadOnlySpan to keep APIs ergonomic and safe?

How do encoding, culture, and globalization affect apps?
How do text encodings, culture (formatting, parsing, comparisons), and globalization (resource localization, collation rules, calendars) influence correctness, security, and user experience in .NET apps, and what patterns/tools does .NET provide to handle them safely and predictably?

DateTime vs DateTimeOffset vs TimeZoneInfo—when to use each?
When should you use DateTime, DateTimeOffset, and TimeZoneInfo in .NET, how do they differ (absolute instant, local/UTC, offsets, time-zone rules), what are the common pitfalls (DST gaps/overlaps, Kind confusion, serialization), and how do you combine them for correct storage, display, and scheduling?

Random vs RandomNumberGenerator—what’s the difference?
When should you use System.Random versus System.Security.Cryptography.RandomNumberGenerator in .NET, how do they differ in predictability, thread-safety, distribution, and APIs, and what patterns avoid common pitfalls like modulo bias and seed collisions?

What are the core LINQ operators and their purposes?
What are the core LINQ operators in .NET, what problems do they solve (filtering, projection, flattening, joining, grouping, ordering, quantifiers, set ops, paging, aggregation, conversion), how do deferred execution and streaming affect performance, and how should you combine them safely (avoid multiple enumeration, materialize when needed, prefer keys/selectors over ad-hoc loops)?

How do EF Core DbContext and DbSet work?
What are DbContext and DbSet in EF Core, how do they relate to change tracking and the unit-of-work pattern, how are queries translated and executed, and what are the common patterns for configuring, adding/updating/removing entities, controlling tracking, relationships loading, and handling transactions/concurrency?

How do EF Core migrations and seeding work?
How do EF Core migrations capture model changes into versioned scripts and how do seeding strategies populate data (reference data, demo data) safely across environments? When should you use HasData vs custom code, and how do you apply migrations at startup or via CLI/CD pipelines without breaking production?

What is change tracking vs No-Tracking in EF Core?
What does change tracking mean in EF Core (how a DbContext detects Added/Modified/Deleted states and generates updates), when should you use tracking vs no-tracking (AsNoTracking, AsNoTrackingWithIdentityResolution), and how do these modes impact performance, memory, and correctness (updates, graphs, concurrency)?

Eager vs lazy vs explicit loading—trade-offs?
In EF Core, how do eager loading (Include/ThenInclude), lazy loading (proxies or manual patterns), and explicit loading (Entry(...).Reference/Collection.Load*) differ in behavior and performance, and when should you choose each to avoid N+1 queries, over-fetching, or stale data?

How do relationships and cascade deletes work in EF Core?
How are relationships (one-to-many, one-to-one, many-to-many) mapped in EF Core, what delete behaviors exist (Cascade, Restrict/NoAction, SetNull, ClientSetNull), how do required vs optional dependents affect defaults, and how do you configure/avoid issues like cycles and multiple cascade paths while keeping data integrity?

How do you manage transactions and isolation levels?
How do you manage transactions in EF Core (implicit vs explicit, ambient scopes, savepoints), choose isolation levels to control anomalies (dirty reads, non-repeatable reads, phantom reads), and coordinate multi-step or multi-context operations safely (commit, rollback, retries) without sacrificing performance or correctness?

EF Core vs Dapper—when to choose each?
How do EF Core (an ORM with LINQ, change tracking, and migrations) and Dapper (a lightweight micro-ORM focused on raw SQL and fast materialization) differ in productivity, control, performance, and features? When should you choose one over the other—or mix them in the same app?

Do you need Repository/Unit of Work with EF Core?
Do you still need the Repository and Unit of Work patterns when using EF Core, and in which situations does adding your own repositories help or hurt maintainability, performance, and testability?

How does ASP.NET Core hosting with Kestrel work?
How does the ASP.NET Core hosting model start and run your app with Kestrel (the built-in cross-platform web server)? How do you configure ports/TLS/protocols, compose the middleware pipeline, run behind a reverse proxy (Nginx/IIS/Apache), and handle lifetime/shutdown and background work?

What is the middleware pipeline and why does order matter?
What is the ASP.NET Core middleware pipeline, how do requests flow through it, and why does the registration order matter for behaviors like exception handling, routing, authentication/authorization, short-circuiting, static files, and custom cross-cutting concerns?

What is the Options pattern and configuration binding?
What is the Options pattern in ASP.NET Core, how does configuration binding map hierarchical config (JSON, env vars, secrets) to typed settings, and when should you use IOptions, IOptionsSnapshot, and IOptionsMonitor (including validation, named options, and change notifications)?

How do logging providers and scopes work in ASP.NET Core?
What are logging providers and scopes in ASP.NET Core, how do you configure levels/filters, emit structured logs, and use scopes to attach per-request metadata like correlation IDs across all log entries?

How do model binding and validation work?
How do model binding and validation work in ASP.NET Core for MVC and Minimal APIs—what are the input sources, selection rules, attributes, and extensibility points—and how do you ensure invalid input returns correct errors (e.g., automatic 400s with [ApiController]) without leaking implementation details?

What are controllers, action results, and filters?
What are controllers, action results, and filters in ASP.NET Core MVC, how do they shape request handling and response generation, and how do you choose between returning IActionResult vs ActionResult(T) while composing cross-cutting behavior with filters?

Minimal APIs vs MVC—when to use each?
What are Minimal APIs and ASP.NET Core MVC, how do they differ in structure, features, and extensibility, and when should you choose one over the other—or mix both in the same application?

Razor Pages vs MVC – differences and use cases?
What are Razor Pages and ASP.NET Core MVC, how do they differ in structure, routing, and development workflow, and when should you choose one over the other—or mix both in the same application?

Blazor Server vs Blazor WebAssembly – trade-offs?
What are Blazor Server and Blazor WebAssembly (WASM), how do they differ in execution model, latency, hosting, security, and offline capabilities, and when should you pick one—or mix both (e.g., WASM with server-hosted APIs)?

What is SignalR and when to use real-time communication?
What is SignalR in ASP.NET Core, which transport(s) does it use, what common patterns (broadcast, groups, presence, streams) does it support, and when is real-time a good architectural choice vs. polling or webhooks?

How do you implement gRPC services in .NET?
What is gRPC in .NET, how do you define contracts with .proto, implement services and clients (unary and streaming), handle errors, deadlines, metadata, TLS, and when should you prefer gRPC over JSON HTTP APIs?

What is HttpClientFactory and how to add resilience (Polly)?
What is HttpClientFactory in .NET, why is it preferred over manually new-ing HttpClient, and how do you add resilience (retry, timeout, circuit-breaker, fallback) using Polly—both for named and typed clients?

How do authentication and authorization differ?
What’s the difference between authentication and authorization in ASP.NET Core, how do schemes (Cookies, JWT Bearer) establish identity, and how do roles, claims, policies, and resource-based checks control access?

How do JWT bearer tokens work in ASP.NET Core?
What are JWT bearer tokens and how do they work in ASP.NET Core—how are tokens issued (signing, claims, expiry), how are they validated (issuer, audience, signature, lifetime), how do you plug in the JWT Bearer authentication handler, and how do claims/roles/scopes drive authorization?

What is ASP.NET Core Identity and when to use it?
What is ASP.NET Core Identity, what problems does it solve (user accounts, hashing, roles, claims, cookies, MFA, account confirmation, password reset), and when should you choose it over rolling your own auth or using an external IdP?

How do you configure CORS correctly?
What is CORS in ASP.NET Core, how do you define policies (default vs. named), apply them globally or per-endpoint, and how do you handle credentials, preflight requests, allowed origins/methods/headers, and security pitfalls (e.g., AllowAnyOrigin + credentials)?

How do streams and async file I/O work?
What are streams in .NET, how do synchronous vs asynchronous file I/O differ, and when should you use FileStream, StreamReader/Writer, CopyToAsync, buffering, CancellationToken, and file options like FileOptions.Asynchronous or FileOptions.SequentialScan?

What is System.IO.Pipelines and when to use it?
What is System.IO.Pipelines, how does it differ from classic Stream APIs, and when should you choose it for high-throughput, low-allocation I/O (e.g., parsing framed network protocols, minimizing copies, and handling backpressure)?

System.Text.Json vs Newtonsoft.Json – differences?
System.Text.Json vs Newtonsoft.Json—differences? Explain how their APIs, defaults, performance, features (attributes, naming, null handling, enums, dates, reference loops, polymorphism), LINQ-to-JSON equivalents, custom converters, and ASP.NET Core integration compare; show when to pick each and how to migrate.

How do configuration providers work?
Explain the configuration system pipeline, how configuration sources (JSON files, environment variables, command-line, user secrets, etc.) combine to produce IConfiguration, how reloading and precedence work, how binding maps to strongly typed objects, and how to extend the system with custom providers.

What are BackgroundService and IHostedService?
Explain how hosted services run with the generic host, the difference between implementing IHostedService directly vs inheriting from BackgroundService, how lifetime, cancellation, and graceful shutdown work, how to create scoped dependencies, schedule periodic work, handle errors, and coordinate multiple hosted services.

How do you choose between Timer types (Timers vs PeriodicTimer)?
How do you choose between Timer types (System.Timers.Timer, System.Threading.Timer, and PeriodicTimer)? Explain their differences in design, threading, async support, use cases, lifecycle management, error handling, and how to pick the right timer for background, async, or high-frequency tasks.

How do IMemoryCache and IDistributedCache work?
How do IMemoryCache and IDistributedCache work in .NET? Explain how each cache type stores data, their lifetimes, use cases, expiration strategies, serialization requirements, performance trade-offs, and when to choose one over the other.

When and how to use Redis caching in .NET?
When and how should Redis caching be used in .NET applications? Explain when Redis is a good fit, how it integrates with IDistributedCache, how to connect and configure it in .NET, how serialization and expiration work, and common patterns such as hybrid caching, pub/sub invalidation, and data partitioning.

How to integrate message queues (Service Bus/RabbitMQ)?
How do you integrate message queues such as Azure Service Bus or RabbitMQ in .NET? Explain how message queues decouple producers and consumers, how to use official .NET SDKs to send and receive messages, how message acknowledgments, dead-letter queues, and retries work, and how to build background message processors safely.

Monolith vs Microservices – how to decide in .NET?
Monolith vs Microservices – how do you decide which architecture to use in .NET? Explain the trade-offs between a single, unified codebase (monolith) and independently deployed services (microservices), the technical and organizational factors that guide the decision, how .NET supports both models, and how to evolve from one to the other safely.

What is TDD and how do we do testing in C#?
What are effective practices for unit testing and TDD in C#? How do frameworks (e.g., xUnit) and patterns (AAA, fakes/mocks, DI) help you write fast, reliable tests—including async and data-driven tests?

How do you test with xUnit/NUnit and Moq?
How do you write unit tests with xUnit and NUnit, and use Moq to isolate dependencies? Explain project setup, assertions, data-driven tests, async testing, arranging mocks/stubs with Moq, verifying interactions, handling exceptions, and test structure for maintainability.

What are the SOLID principles?
What are the SOLID principles in C#, why do they matter, and how do you apply them without over-engineering?

Which design patterns are common in .NET?
Which design patterns are commonly used in .NET, and how do you implement them in production-oriented code? Explain intent, trade-offs, and practical implementations of patterns such as Factory Method/Abstract Factory, Strategy, Adapter, Decorator, Observer/Events, and Mediator, and when to prefer DI over Singletons.

How do you profile and benchmark with BenchmarkDotNet?
How do you use BenchmarkDotNet to produce reliable microbenchmarks in .NET, and how does it relate to profiling? Explain when to benchmark vs profile, how to set up BenchmarkDotNet, write trustworthy benchmarks (warmup, iteration counts, baselines, parameters, memory diagnoser), read results, avoid dead-code elimination, and combine Benchmarks with profilers or diagnosers.

What is tiered compilation and ReadyToRun?
What are tiered compilation and ReadyToRun in .NET, and how do they affect startup, throughput, and deployment? Explain how tiered compilation uses quick JIT (Tier 0) then optimizes hot methods (Tier 1/PGO), how to observe and influence it, what ReadyToRun (R2R) native images are, how they speed up cold start, trade-offs (size, crossgen vs JIT quality), and when to enable or avoid each.

What is Native AOT and assembly trimming?
What are Native AOT and assembly trimming in .NET, and when should you use them? Explain how Native AOT compiles IL to platform-native code at publish time for startup speed and small self-contained binaries, how it differs from ReadyToRun, how assembly trimming removes unused code, what risks reflection introduces, and how to control and verify trimming safety.

How does P/Invoke and interop with native code work?
How does Platform Invocation (P/Invoke) let .NET call native libraries, and how do you design correct, safe interop? Explain DllImport/LibraryImport, calling conventions, character sets, marshaling (blittable vs non-blittable), struct layout, error handling (SetLastError), resource ownership (SafeHandle), callbacks/delegates, and when to prefer alternatives like System.Runtime.InteropServices.JavaScript, COM, or generated interop.

How do MSBuild and SDK-style csproj files work?
How does the build system MSBuild work with the modern SDK-style .csproj files, and what are the key concepts you should know for practical .NET development? Cover: SDK attribute, implicit imports, PropertyGroup/ItemGroup, build lifecycle (restore → compile → pack → publish), multi-targeting, file globbing, customizing targets/props, conditions, and useful hooks.

How do you create and version NuGet packages?
How do you create, configure, and version NuGet packages in .NET? Cover SDK-style packing with dotnet pack/GeneratePackageOnBuild, required metadata (id, version, authors, license), semantic versioning (stable vs prerelease), symbols/SourceLink, multi-targeting and dependencies, README/icon, and publishing to feeds (nuget.org, GitHub Packages, private feeds).

What deployment options exist (IIS, containers, Azure)?
What are the common deployment options for .NET/ASP.NET Core applications—including on-premises and cloud—and how do you choose between deploying to Internet Information Services (IIS), containers, and Azure App Service/other Azure services?

Student Ratings & Reviews

No Review Yet
No Review Yet