Course Content
Introduction
Welcome to the Course
0/3
Welcome to the Course!
Before You Start: Setup Requirements
How to Approach This 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?
0/6
What is .NET CLI? – Theory and Examples
What is .NET CLI? - Knowledge Check
Hands-On: Scaffold, Depend, Run (Easy)
Solution: Scaffold, Depend, Run
Hands-On: Multi-Project App: Web API + Library + Tooling (Advanced)
Solution: Multi-Project App: Web API + Library + Tooling
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)?
0/6
What is the CLR? – Theory and Examples
What is the CLR? - Knowledge Check
Hands-On: Trace the Execution Path (Easy)
Solution: Trace the Execution Path
Hands-On: Mini Loader: Inspect Assemblies and Execute Strategically (Advanced)
Solution: Mini Loader: Inspect Assemblies and Execute Strategically
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?
0/6
How do .NET Framework, .NET Core, and modern .NET differ? – Theory and Examples
How do .NET Framework, .NET Core, and modern .NET differ? - Knowledge Check
Hands-On: Build Once, Target Twice (Easy)
Solution: Build Once, Target Twice
Hands-On: Porting Shim: One Codebase, Mixed APIs (Advanced)
Solution: Porting Shim: One Codebase, Mixed APIs
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?
0/6
What’s the difference between stack and heap memory? – Theory and Examples
What’s the difference between stack and heap memory? - Knowledge Check
Hands-On: Stack or Heap? Measure It (Easy)
Solution: Stack or Heap? Measure It
Hands-On: Heap vs Stack Analyzer: Find Hot Allocations and Fix (Advanced)
Solution: Heap vs Stack Analyzer: Find Hot Allocations and Fix
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?
0/6
What is Garbage Collector (GC) and how does it work? – Theory and Examples
What is Garbage Collector (GC) and how does it work? - Knowledge Check
Hands-On: Make a Disposable Wrapper Correctly (Easy)
Solution: Make a Disposable Wrapper Correctly
Hands-On: Track Promotions and Collections with Weak References (Advanced)
Solution: Track Promotions and Collections with Weak References
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?
0/6
What are boxing and unboxing? – Theory and Examples
What are boxing and unboxing? - Knowledge Check
Hands-On: Find and Remove Hidden Boxing (Easy)
Solution: Find and Remove Hidden Boxing
Hands-On: Boxing Aware API: Two Overloads + Analyzer Checklist (Advanced)
Solution: Boxing Aware API: Two Overloads + Analyzer Checklist
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?
0/6
Value Types vs Reference Types
Value Types vs Reference Types Knowledge Check
Hands-On: Fix the Struct Copy Bug (Easy)
Solution: Fix the Struct Copy Bug
Hands‑On: Vector Math & Simulation (Advanced)
Solution: Vector Math & Simulation
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?
0/6
When would you use a struct vs a class? – Theory and Examples
When would you use a struct vs a class? - Knowledge Check
Hands-On: Pick the Right Shape (Easy)
Solution: Pick the Right Shape
Hands-On: High-Perf Geometry (Advanced)
Solution: High-Perf Geometry
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?
0/6
Encapsulation – Theory and Examples
Encapsulation Knowledge Check
Hands-On: Encapsulated Account (Easy)
Solution: Encapsulated Account
Hands-On: Inventory with Encapsulated Collection & Invariants (Advanced)
Solution: Inventory with Encapsulated Collection & Invariants
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?
0/6
Polymorphism – Theory and Examples
Polymorphism Knowledge Check
Hands-On: Shapes Polymorphism Refactor (Easy)
Solution: Shapes Polymorphism Refactor
Hands-On: Pricing Engine: Rules as Polymorphic Strategies (Advanced)
Solution: Pricing Engine: Rules as Polymorphic Strategies
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?
0/6
Interfaces vs Abstract Classes – Theory and Examples
Interfaces vs Abstract Classes Knowledge Check
Hands-On: Logger via Interface vs Abstract Class (Easy)
Solution: Logger via Interface vs Abstract Class
Hands-On: Exporters with Shared Pipeline (Advanced)
Solution: Exporters with Shared Pipeline
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)?
0/6
LINQ & Deferred Execution – Theory and Examples
LINQ & Deferred Execution Knowledge Check
Hands-On: Live vs Snapshot (Easy)
Solution: Live vs Snapshot
Hands-On: Implement Batch and Memoize (Advanced)
Solution: Implement Batch and Memoize
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?
0/6
async/await & Tasks – Theory and Examples
async/await & Tasks Knowledge Check
Hands-On: DownloadAllAsync – concurrent, cancellable (Easy)
Solution: DownloadAllAsync – concurrent, cancellable
Hands-On: “Polite Fetcher” (Advanced)
Solution: “Polite Fetcher”
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?
0/6
IDisposable & Resource Management – Theory and Examples
IDisposable & Resource Management Knowledge Check
Hands-On: Scoped Stopwatch + File Sink (Easy)
Solution: Scoped Stopwatch + File Sink
Hands-On: Composite Disposable (Advanced)
Solution: Composite Disposable
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?
0/6
using statement vs using declaration – Theory and Examples
using statement vs using declaration - Knowledge Check
Hands-On: Tight vs Wide Lifetimes (Easy)
Solution: Tight vs Wide Lifetimes
Hands-On: Async Pipeline: Mix Declarations and Statements Safely (Advanced)
Solution: Async Pipeline: Mix Declarations and Statements Safely
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?
0/6
Dependency Injection (DI) – Theory and Examples
Dependency Injection (DI) Knowledge Check
Hands-On: Refactor to DI: Time-Stamped Greeter (Easy)
Solution: Refactor to DI: Time-Stamped Greeter
Hands-On: Mini Request Pipeline: Scoped + Factory + Disposal (Advanced)
Solution: Mini Request Pipeline: Scoped + Factory + Disposal
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?
0/6
Exceptions & Error Handling – Theory and Examples
Exceptions & Error Handling Knowledge Check
Hands-On: Range Math with Proper Exceptions (Easy)
Solution: Range Math with Proper Exceptions
Hands-On: Resilient Operation Runner (Advanced)
Solution: Resilient Operation Runner
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?
0/6
Why is immutability useful and how to implement it?
Why is immutability useful and how to implement it? - Knowledge Check
Hands-On: Refactor to Immutable (Easy)
Solution: Refactor to Immutable
Hands-On: Thread-Safe, Immutable Catalog with Atomic Publishing (Advanced)
Solution: Thread-Safe, Immutable Catalog with Atomic Publishing
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?
0/6
String Immutability and String Interning – Theory and Examples
String Immutability and String Interning - Knowledge Check
Hands-On: Canonicalize a Small Token Set with Interning (Easy)
Solution: Canonicalize a Small Token Set with Interning
Hands-On: Mini Symbol Table with Safe Interning (Advanced)
Solution: Mini Symbol Table with Safe Interning
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?
0/6
When to use StringBuilder? – Theory and Examples
When to use StringBuilder? - Knowledge Check
Hands-On: CSV Builder (Easy)
Solution: CSV Builder
Hands-On: Template Renderer with Capacity Planning (Advanced)
Solution: Template Renderer with Capacity Planning
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?
0/6
Collections & Generics – Theory and Examples
Collections & Generics Knowledge Check
Hands-On: Word Frequency (Case-Insensitive) (Easy)
Solution: Word Frequency (Case-Insensitive)
Hands-On: Generic LRU Cache (Dictionary + LinkedList) (Advanced)
Solution: Generic LRU Cache (Dictionary + LinkedList)
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?
0/6
Memory & Span – Theory and Examples
Memory & Span Knowledge Check
Hands-On: Parse Content-Length Without Substring (Easy)
Solution: Parse Content-Length Without Substring
Hands-On: Hex Encode/Decode with Spans (Zero-Allocation API) (Advanced)
Solution: Hex Encode/Decode with Spans (Zero-Allocation API)
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?
0/6
Threading & Synchronization – Theory and Examples
Threading & Synchronization Knowledge Check
Hands-On: Thread-Safe Counter Three Ways (Easy)
Solution: Thread-Safe Counter Three Ways
Hands-On: Bounded Producer/Consumer (Advanced)
Solution: Bounded Producer/Consumer (SemaphoreSlim + ConcurrentQueue)
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?
0/6
What are Delegates in C#? (Func, Action) – Theory and Examples
What are Delegates in C#? (Func, Action) - Knowledge Check
Hands-On: Repeat, Transform, Report (Easy)
Solution: Repeat, Transform, Report
Hands-On: Pipeline: Parse, Filter, Project, Act (Advanced)
Solution: Pipeline: Parse, Filter, Project, Act
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?
0/6
Publisher/Subscriber Pattern – Theory and Examples
Publisher/Subscriber Pattern - Knowledge Check
Hands-On: AsyncNotifier with Awaitable Subscribers (Easy)
Solution: AsyncNotifier with Awaitable Subscribers
Hands-On: Async Event Bus (Advanced)
Solution: Async Event Bus
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?
0/6
Serialization & Deserialization – Theory and Examples
Serialization & Deserialization - Knowledge Check
Hands-On: Profile JSON Settings (Easy)
Solution: Profile JSON Settings
Hands-On: Custom Converters: DateOnly + Value Object (Advanced)
Solution: Custom Converters: DateOnly + Value Object
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?
0/6
IEnumerable vs IQueryable – Theory and Examples
IEnumerable vs IQueryable - Knowledge Check
Hands-On: Split Server Filter from Client Projection (Easy)
Solution: Split Server Filter from Client Projection
Hands-On: Provider-Safe Search with Optional Terms (Advanced)
Solution: Provider-Safe Search with Optional Terms
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?
0/6
What is IAsyncEnumerable? – Theory and Examples
What is IAsyncEnumerable? - Knowledge Check
Hands-On: Async Grep: Stream file lines with cancellation (Easy)
Solution: Async Grep: Stream file lines with cancellation
Hands-On: Paged API Fetcher as an Async Stream (Advanced)
Solution: Paged API Fetcher as an Async Stream
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?
0/6
What is an array (T[])? – Theory and Examples
What is Array<T>? - Knowledge Check
Hands-On: Reverse Array In-Place (Easy)
Solution: Reverse Array In-Place
Hands-On: Array Utilities: EnsureCapacity, InsertAt, RemoveAt (Advanced)
Solution: Array Utilities: EnsureCapacity, InsertAt, RemoveAt
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 &amp; equality), and how do you use it correctly for performance and correctness (capacity, lookups, custom comparers, custom key types, and thread-safety)?
0/6
What is Dictionary? – Theory and Examples
What is Dictionary? - Knowledge Check
Hands-On: The Orphaned Entry: Mutating a Key Already in a Dictionary (Easy)
Solution: The Orphaned Entry: Mutating a Key Already in a Dictionary
Hands-On: Instrumenting a Dictionary: Count What It Asks Your Comparer (Advanced)
Solution: Instrumenting a Dictionary: Count What It Asks Your Comparer
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)?
0/6
What is List? – Theory and Examples
What is List? - Knowledge Check
Hands-On: Unique, Sorted Names (Easy)
Solution: Unique, Sorted Names
Hands-On: List Lab: Growth, Compaction and the Version Check (Advanced)
Solution: List Lab: Growth, Compaction and the Version Check
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)?
0/6
What is Queue? – Theory and Examples
What is Queue? - Knowledge Check
Hands-On: Print Server FIFO (Easy)
Solution: Print Server FIFO
Hands-On: Build a Bounded Circular Queue (Advanced)
Solution: Build a Bounded Circular Queue
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)?
0/6
What is Stack? – Theory and Examples
What is Stack? - Knowledge Check
Hands-On: Balanced Parentheses (Single Scan) (Easy)
Solution: Balanced Parentheses (Single Scan)
Hands-On: Undo/Redo with Two Stacks (Advanced)
Solution: Undo/Redo with Two Stacks
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?
0/6
What are concurrent collections and when to use them?
What are concurrent collections and when to use them? - Knowledge Check
Hands-On: Top-K Words with ConcurrentDictionary (Easy)
Solution: Top-K Words with ConcurrentDictionary
Hands-On: Bounded Work Queue with BlockingCollection (Advanced)
Solution: Bounded Work Queue with BlockingCollection
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?
0/6
What are records and record structs? – Theory and Examples
What are record and record struct? - Knowledge Check
Hands-On: Immutable Contact Card with “with” (Easy)
Solution: Immutable Contact Card with “with”
Hands-On: Discriminated Union with Records (Advanced)
Solution: Discriminated Union with Records
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?
0/6
What is pattern matching? – Theory and Examples
What is pattern matching? - Knowledge Check
Hands-on: Shape classifier with patterns (Easy)
Solution: Shape classifier with patterns
Hands-On: Mini router with property + list patterns (Advanced)
Solution: Mini router with property + list patterns
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)?
0/6
What are attributes in C#? – Theory and Examples
What are attributes in C#? - Knowledge Check
Hands-On: Describe Metadata for a Mini Model (Easy)
Solution: Describe Metadata for a Mini Model
Hands-On: Attribute-Driven Command Router (Advanced)
Solution: Attribute-Driven Command Router
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?
0/6
What are nullable reference types? – Theory and Examples
What are nullable reference types? - Knowledge Check
Hands-On: Null-Safe Parsing Utility (Easy)
Solution: Null-Safe Parsing Utility
Hands-On: Boundary Cleaner: NRT-Aware DTO Deserialization (Advanced)
Solution: Boundary Cleaner: NRT-Aware DTO Deserialization
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?
0/6
When to use Parallel.ForEach vs PLINQ? – Theory and Examples
When to use Parallel.ForEach vs PLINQ? - Knowledge Check
Hands-On: Histogram with Parallel.ForEach (Easy)
Solution: Histogram with Parallel.ForEach
Hands-On: PLINQ Pipeline with Ordering and Cancellation (Advanced)
Solution: PLINQ Pipeline with Ordering and Cancellation
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?
0/6
How do lock, Monitor, Mutex, and SemaphoreSlim differ?
How do lock, Monitor, Mutex, and SemaphoreSlim differ? - Knowledge Check
Hands-On: Protect a Shared Cache (Easy)
Solution: Protect a Shared Cache
Hands-On: Bounded Buffer: Blocking & Async Variants (Advanced)
Solution: Bounded Buffer: Blocking & Async Variants
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?
0/6
What are covariance and contravariance?
What are covariance and contravariance? - Knowledge Check
Hands-On: Make your API variance-friendly (Easy)
Solution: Make your API variance-friendly
Hands-On: Plugin pipeline with producers and consumers (Advanced)
Solution: Plugin pipeline with producers and consumers
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?
0/6
How do events work in C#?
How do events work in C#? - Knowledge Check
Hands-On: Mini Timer with EventHandler (Easy)
Solution: Mini Timer with EventHandler
Hands-On: Downloader with Progress and Completed events (Advanced)
Solution: Downloader with Progress and Completed events
What are lambdas and expression trees?
What are lambdas in C# and how do expression trees differ from delegate lambdas?
0/6
What are lambdas and expression trees?
What are lambdas and expression trees? - Knowledge Check
Hands-On: Dynamic Where builder (Easy)
Solution: Dynamic Where builder
Hands-On: Mini rule engine: expression tree rewrite & compile (Advanced)
Solution: Mini rule engine: expression tree rewrite & compile
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?
0/6
What are source generators and typical use cases?
What are source generators and typical use cases? - Knowledge Check
Hands-On: Hello Generator + Consumer (Easy)
Solution: Hello Generator + Consumer
Hands-On: AutoNotify incremental generator (Advanced)
Solution: AutoNotify incremental generator
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?
0/6
What is the dynamic keyword and DLR?
What is the dynamic keyword and DLR?
Hands-On: Mini dynamic JSON viewer (Easy)
Solution: Mini dynamic JSON viewer
Hands-On: Dynamic plugin invoker with DLR fallback (Advanced)
Solution: Dynamic plugin invoker with DLR fallback
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?
0/6
How do properties, indexers, and init-only setters work?
How do properties, indexers, and init-only setters work? - Knowledge Check
Hands-On: Contacts with indexer and init options (Easy)
Solution: Contacts with indexer and init options
Hands-On: RingBuffer with Index/Range indexers and init invariants (Advanced)
Solution: RingBuffer with Index/Range indexers and init invariants
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 </&gt;, ==/!=), and how do you combine it with IEquatable&lt;T>, IComparable, and user-defined conversions to build safe, intuitive value types?
0/6
How do you implement operator overloading?
How do you implement operator overloading? - Knowledge Check
Hands-On: Rational numbers with basic operators (Easy)
Solution: Rational numbers with basic operators
Hands-On: Complex numbers with arithmetic, equality, and conversions (Advanced)
Solution: Complex numbers with arithmetic, equality, and conversions
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?
0/6
What are iterators and yield return?
What are iterators and yield return? - Knowledge Check
Hands-On: Fibonacci sequence (first N numbers) (Easy)
Solution: Fibonacci sequence (first N numbers)
Hands-On: Recursive directory walk with filters (lazy) (Advanced)
Solution: Recursive directory walk with filters (lazy)
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?
0/6
How do extension methods work and when to use them?
How do extension methods work and when to use them? - Knowledge Check
Hands-On: String helpers: IsNullOrWhiteSpace and Truncate (Easy)
Solution: String helpers: IsNullOrWhiteSpace and Truncate
Hands-On: Mini LINQ-style utilities: GetOrAdd, DistinctBy, Batch (Advanced)
Solution: Mini LINQ-style utilities: GetOrAdd, DistinctBy, Batch
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)?
0/6
What are partial classes and partial methods?
What are partial classes and partial methods? - Knowledge Check
Hands-On: Split and hook: User with optional rename log (Easy)
Solution: Split and hook: User with optional rename log
Hands-On: Generated API client with partial hooks (Advanced)
Solution: Generated API client with partial hooks
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?
0/6
What are top-level statements and global usings?
What are top-level statements and global usings? - Knowledge Check
Hands-On: Top-level args and exit codes (Easy)
Solution: Top-level args and exit codes
Hands-On: Project-wide imports with global usings + a tiny CLI (Advanced)
Solution: Project-wide imports with global usings + a tiny CLI
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?
0/6
What are primary constructors in C#?
What are primary constructors in C#? - Knowledge Check
Hands-On: Refactor to primary constructor (Easy)
Solution: Refactor to primary constructor
Hands-On: HTTP client options (Advanced)
Solution: HTTP client options
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?
0/6
What are nameof, var, and target-typed new?
What are nameof, var, and target-typed new? - Knowledge Check
Hands-On: Clean guards and allocations (Easy)
Solution: Clean guards and allocations
Hands-On: Mini mapper with diagnostics (Advanced)
Solution: Mini mapper with diagnostics
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, &amp;, *, -&gt;, 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?
0/6
When and how would you use unsafe code and pointers?
When and how would you use unsafe code and pointers? - Knowledge Check
Hands-On: Reverse a Span in place using pointers (Easy)
Solution: Reverse a Span in place using pointers
Hands-On: ASCII uppercase converter with stack buffer and pointers (Advanced)
Solution: ASCII uppercase converter with stack buffer and pointers
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?
0/6
How do encoding, culture, and globalization affect apps?
How do encoding, culture, and globalization affect apps? - Knowledge Check
Hands-On: Culture-safe number parsing and formatting (Easy)
Solution: Culture-safe number parsing and formatting
Hands-On: Locale-aware sorting, searching, and normalization pipeline (Advanced)
Solution: Locale-aware sorting, searching, and normalization pipeline
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?
0/6
DateTime vs DateTimeOffset vs TimeZoneInfo – when to use each?
DateTime vs DateTimeOffset vs TimeZoneInfo - Knowledge Check
Hands-On: Safe timestamping & display (Easy)
Solution: Safe timestamping & display
Hands-On: Daily scheduler in a time zone (DST safe) (Advanced)
Solution: Daily scheduler in a time zone (DST safe)
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?
0/6
Random vs RandomNumberGenerator – what’s the difference?
Random vs RandomNumberGenerator - Knowledge Check
Hands-On: Playlist shuffle vs secure winner pick (Easy)
Solution: Playlist shuffle vs secure winner pick
Hands-On: Secure token + unbiased lottery bucket (Advanced)
Solution: Secure token + unbiased lottery bucket
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)?
0/6
What are the core LINQ operators and their purposes?
What are the core LINQ operators and their purposes? - Knowledge Check
Hands-On: Top sellers by category (Easy)
Solution: Top sellers by category
Hands-On: Customer order rollup with joins and paging (Advanced)
Solution: Customer order rollup with joins and paging
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?
0/6
How do EF Core DbContext and DbSet work?
How do EF Core DbContext and DbSet work? - Knowledge Check
Hands-On: Products CRUD basics with tracking control (Easy)
Solution: Products CRUD basics with tracking control
Hands-On: Orders rollup with Include, concurrency, and transaction (Advanced)
Solution: Orders rollup with Include, concurrency, and transaction
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?
0/6
How do EF Core migrations and seeding work?
How do EF Core migrations and seeding work? - Knowledge Check
Hands-On: Initial migration + HasData seeding (Easy)
Solution: Initial migration + HasData seeding
Hands-On: Idempotent code-based seeding after migrations (Advanced)
Solution: Idempotent code-based seeding after migrations
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)?
0/6
What is change tracking vs No-Tracking in EF Core?
What is change tracking vs No-Tracking in EF Core? - Knowledge Check
Hands-On: List vs Edit: pick the right tracking mode (Easy)
Solution: List vs Edit: pick the right tracking mode
Hands-On: Detached DTO update vs tracked edit (Advanced)
Solution: Detached DTO update vs tracked edit
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?
0/6
Eager vs lazy vs explicit loading – trade-offs?
Eager vs lazy vs explicit loading - Knowledge Check
Hands-On: Choose the right loading strategy for a list + detail (Easy)
Solution: Choose the right loading strategy for a list + detail
Hands-On: Conditional loading with explicit vs lazy vs eager (Advanced)
Solution: Conditional loading with explicit vs lazy vs eager
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?
0/6
How do relationships and cascade deletes work in EF Core?
How do relationships and cascade deletes work in EF Core? - Knowledge Check
Hands-On: Blog posts with SetNull on delete (Easy)
Solution: Blog posts with SetNull on delete
Hands-On: Orders model with mixed delete behaviors (Advanced)
Solution: Orders model with mixed delete behaviors
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?
0/6
How do you manage transactions and isolation levels?
How do you manage transactions and isolation levels? - Knowledge Check
Hands-On: Atomic transfer with explicit transaction (Easy)
Solution: Atomic transfer with explicit transaction
Hands-On: Outbox-style order create with savepoint and isolation (Advanced)
Solution: Outbox-style order create with savepoint and isolation
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?
0/6
EF Core vs Dapper – when to choose each?
EF Core vs Dapper - Knowledge Check
Hands-On: EF Core vs Dapper basic CRUD (Easy)
Solution: EF Core vs Dapper basic CRUD
Hands-On: Hybrid repository: EF for writes, Dapper for hot read (Advanced)
Solution: Hybrid repository: EF for writes, Dapper for hot read
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?
0/4
Do you need Repository/Unit of Work with EF Core?
Do you need Repository/Unit of Work with EF Core? - Knowledge Check
Hands-On: Add value: specification-based read repository + service (Advanced)
Solution: Add value: specification-based read repository + service
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?
0/6
How does ASP.NET Core hosting with Kestrel work?
How does ASP.NET Core hosting with Kestrel work? - Knowledge Check
Hands-On: Bind Kestrel, add health, and graceful shutdown (Easy)
Solution: Bind Kestrel, add health, and graceful shutdown
Hands-On: Reverse proxy-ready app with forwarded headers, limits, and background work (Advanced)
Solution: Reverse proxy-ready app with forwarded headers, limits, and background work
00:00
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?
0/6
What is the middleware pipeline and why does order matter?
What is the middleware pipeline and why does order matter? - Knowledge Check
Hands-On: Fix the pipeline order (Easy)
Solution: Fix the pipeline order
Hands-On: Instrumented pipeline with branching, timing, and correlation (Advanced)
Solution: Instrumented pipeline with branching, timing, and correlation
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)?
0/6
What is the Options pattern and configuration binding?
What is the Options pattern and configuration binding? - Knowledge Check
Hands-On: Bind, validate, and read settings (Easy)
Solution: Bind, validate, and read settings
Hands-On: Named options with live reload and change hook (Advanced)
Solution: Named options with live reload and change hook
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?
0/6
How do logging providers and scopes work in ASP.NET Core?
How do logging providers and scopes work in ASP.NET Core? - Knowledge Check
Hands-On: Add correlation scope and structured logs (Easy)
Solution: Add correlation scope and structured logs
Hands-On: Category filters + high-perf logs + nested scopes (Advanced)
Solution: Category filters + high-perf logs + nested scopes
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?
0/6
How do model binding and validation work?
How do model binding and validation work? - Knowledge Check
Hands-On: MVC auto-validation (Easy)
Solution: MVC auto-validation
Hands-On: Custom binding for comma-separated GUIDs + validation (Advanced)
Solution: Custom binding for comma-separated GUIDs + validation
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?
0/6
What are controllers, action results, and filters?
What are controllers, action results, and filters? - Knowledge Check
Hands-On: Return different results from one action (Easy)
Solution: Return different results from one action
Hands-On: Global exception handling (Advanced)
Solution: Filters and Global Exception Handling
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?
0/6
Minimal APIs vs MVC – when to use each?
Minimal APIs vs MVC - Knowledge Check
Hands-On: Split endpoints: Minimal for health, MVC for orders (Easy)
Solution: Split endpoints: Minimal for health, MVC for orders
Hands-On: Design a hybrid API (Advanced)
Solution: Design a hybrid API
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?
0/6
Razor Pages vs MVC – differences and use cases?
Razor Pages vs MVC - Knowledge Check
Hands-On: Convert a form to Razor Pages handlers (Easy)
Solution: Convert a form to Razor Pages handlers
Hands-On: Hybrid UI: Razor Pages for UI + MVC for API (Advanced)
Solution: Hands-On: Hybrid UI: Razor Pages for UI + MVC for API
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)?
0/6
Blazor Server vs Blazor WebAssembly – trade-offs?
Blazor Server vs Blazor WebAssembly - Knowledge Check
Hands-On: Choose and justify: Server vs WASM (Easy)
Solution: Choose and justify: Server vs WASM
Hands-On: Hybrid app: prerendered WASM UI + server API, resilient to network hiccups (Advanced)
Solution: Hybrid app: prerendered WASM UI + server API, resilient to network hiccups
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?
0/6
What is SignalR and when to use real-time communication?
What is SignalR and when to use real-time communication? - Knowledge Check
Hands-On: Chat in 40 lines (Easy)
Solution: Chat in 40 lines
Hands-On: Live prices with groups, auth, and scale-out (Advanced)
Solution: Live prices with groups, auth, and scale-out
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?
0/6
How do you implement gRPC services in .NET?
How do you implement gRPC services in .NET? - Knowledge Check
Hands-On: Hello gRPC: unary + server streaming (Easy)
Solution: Hello gRPC: unary + server streaming
Hands-On: Bi-di streaming with metadata, deadlines, and retry via interceptor (Advanced)
Solution: Bi-di streaming with metadata, deadlines, and retry via interceptor
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?
0/6
What is HttpClientFactory and how to add resilience (Polly)?
What is HttpClientFactory and how to add resilience (Polly)? - Knowledge Check
Hands-On: Make a resilient named client (Easy)
Solution: Make a resilient named client
Hands-On: Resilient Typed Client for a Catalog API (retry, timeout, circuit, bulkhead, fallback) (Advanced)
Solution: Resilient Typed Client for a Catalog API (retry, timeout, circuit, concurrency limiter, fallback)
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?
0/6
How do authentication and authorization differ?
How do authentication and authorization differ? - Knowledge Check
Hands-On: Cookie login + role/claim authorization (minimal API) (Easy)
Solution: Cookie login + role/claim authorization (minimal API)
Hands-On: JWT + Policy + Resource-based authorization (Advanced)
Solution: JWT + Policy + Resource-based authorization
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?
0/6
How do JWT bearer tokens work in ASP.NET Core?
How do JWT bearer tokens work in ASP.NET Core? - Knowledge Check
Hands-On: Local HS256 token + protected endpoint (Easy)
Solution: Local HS256 token + protected endpoint
Hands-On: External issuer (RS256), scope policy, refresh-ready (Advanced)
Solution: External issuer (RS256), scope policy, refresh-ready
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?
0/6
What is ASP.NET Core Identity and when to use it?
What is ASP.NET Core Identity and when to use it? - Knowledge Check
Hands-On: Email confirmation gate + role-restricted endpoint (Easy)
Solution: Email confirmation gate + role-restricted endpoint
Hands-On: Identity with external login + 2FA + password reset (Advanced)
Solution: Identity with external login + 2FA + password reset
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)?
0/6
How do you configure CORS correctly?
How do you configure CORS correctly? - Knowledge Check
Hands-On: SPA + API CORS (Easy)
Solution: SPA + API CORS
Hands-On: Multi-tenant allow-list + per-endpoint overrides (Advanced)
Solution: Multi-tenant allow-list + per-endpoint overrides
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?
0/6
How do streams and async file I/O work?
How do streams and async file I/O work? - Knowledge Check
Hands-On: Filter a large text file asynchronously (Easy)
Solution: Filter a large text file asynchronously
Hands-On: Chunked copier with progress, throttle, and resume (Advanced)
Solution: Chunked copier with progress, throttle, and resume
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)?
0/6
What is System.IO.Pipelines and when to use it?
What is System.IO.Pipelines and when to use it? - Knowledge Check
Hands-On: Line reader with PipeReader over a Stream (Easy)
Solution: Line reader with PipeReader over a Stream
Hands-On: Length-prefixed protocol server with Pipelines (Advanced)
Solution: Length-prefixed protocol server with Pipelines
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.
0/6
System.Text.Json vs Newtonsoft.Json – differences?
System.Text.Json vs Newtonsoft.Json - differences? - Knowledge Check
Hands-On: Dual-serialize with identical output (Easy)
Solution: Dual-serialize with identical output
Hands-On: Polymorphic messages + custom Money converter (Advanced)
Solution: Polymorphic messages + custom Money converter
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.
0/6
How do configuration providers work?
How do configuration providers work? - Knowledge Check
Hands-On: Inspect configuration values from multiple sources (Easy)
Solution: Inspect configuration values from multiple sources
Hands-On: Build a custom API-based configuration provider (Advanced)
Solution: Build a custom API-based configuration provider
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.
0/6
What are BackgroundService and IHostedService?
What are BackgroundService and IHostedService? - Knowledge Check
Hands-On: Periodic logger BackgroundService (Easy)
Solution: Periodic logger BackgroundService
Hands-On: Channel-based job queue with multiple BackgroundService workers (Advanced)
Solution: Channel-based job queue with multiple BackgroundService workers
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.
0/6
How do you choose between Timer types (Timers vs PeriodicTimer)?
How do you choose between Timer types (Timers vs PeriodicTimer)? - Knowledge Check
Hands-On: Async ticker with PeriodicTimer (Easy)
Solution: Async ticker with PeriodicTimer
Hands-On: Comparing performance and precision of Timer types (Advanced)
Solution: Comparing performance and precision of Timer types
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.
0/6
How do IMemoryCache and IDistributedCache work?
How do IMemoryCache and IDistributedCache work? - Knowledge Check
Hands-On: Cache API response locally (Easy)
Solution: Cache API response locally
Hands-On: Hybrid caching layer with fallback (Advanced)
Solution: Hybrid caching layer with fallback
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.
0/6
When and how to use Redis caching in .NET?
When and how to use Redis caching in .NET? - Knowledge Check
Hands-On: Redis-backed message counter (Easy)
Solution: Redis-backed message counter
Hands-On: Redis hybrid cache with refresh policy (Advanced)
Solution: Redis hybrid cache with refresh policy
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.
0/6
How to integrate message queues (Service Bus/RabbitMQ)?
How to integrate message queues (Service Bus/RabbitMQ)? - Knowledge Check
Hands-On: Basic message queue demo (Easy)
Solution: Basic message queue demo
Hands-On: Background order processor with Service Bus (Advanced)
Solution: Background order processor with Service Bus
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.
0/6
Monolith vs Microservices – how to decide in .NET?
Monolith vs Microservices - Knowledge Check
Hands-On: Compare API responses of monolith and microservice (Easy)
Solution: Compare API responses of monolith and microservice
Hands-On: Refactoring a modular monolith into microservices (Advanced)
Solution: Refactoring a modular monolith into microservices
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?
0/6
Testing & TDD – Theory and Examples
Testing & TDD Knowledge Check
Hands-On: GreetService (Clock seam) with xUnit (Easy)
Solution: GreetService (Clock seam) with xUnit
Hands-On: OrderService with Repo + Email (Advanced)
Solution: OrderService with Repo + Email
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.
0/6
How do you test with xUnit/NUnit and Moq?
How do you test with xUnit/NUnit and Moq? - Knowledge Check
Hands-On: Service with clock dependency: xUnit + Moq (Easy)
Solution: Service with clock dependency: xUnit + Moq
Hands-On: Catalog service with repository and cache: xUnit + NUnit + Moq (Advanced)
Solution: Catalog service with repository and cache: xUnit + NUnit + Moq
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?
0/6
SOLID Principles – Theory and Examples
SOLID Principles - Knowledge Check
Hands-On: Email Signup: SRP + DIP Refactor (Easy)
Solution: Email Signup: SRP + DIP Refactor
Hands-On: Payments: Apply All SOLID (Advanced)
Solution: Payments: Apply All SOLID
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.
0/6
Which design patterns are common in .NET?
Which design patterns are common in .NET? - Knowledge Check
Hands-On: Shipping cost strategies (Easy)
Solution: Shipping cost strategies
Hands-On: Pluggable email pipeline: Factory + Adapter + Decorator + Strategy (Advanced)
Solution: Pluggable email pipeline: Factory + Adapter + Decorator + Strategy
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.
0/6
How do you profile and benchmark with BenchmarkDotNet?
How do you profile and benchmark with BenchmarkDotNet? - Knowledge Check
Hands-On: String concatenation vs StringBuilder with BenchmarkDotNet (Easy)
Solution: String concatenation vs StringBuilder with BenchmarkDotNet
Hands-On: Algorithm regression guard: compare two implementations across runtimes (Advanced)
Solution: Algorithm regression guard: compare two implementations across runtimes
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.
0/6
What is tiered compilation and ReadyToRun?
What is tiered compilation and ReadyToRun? - Knowledge Check
Hands-On: Measure tiered compilation effect in a hot loop (Easy)
Solution: Measure tiered compilation effect in a hot loop
Hands-On: Startup vs throughput: ReadyToRun + Tiered PGO (Advanced)
Solution: Startup vs throughput: ReadyToRun + Tiered PGO
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.
0/6
What is Native AOT and assembly trimming?
What is Native AOT and assembly trimming? - Knowledge Check
Hands-On: Trim and measure binary size (Easy)
Solution: Trim and measure binary size
Hands-On: Portable tool with Native AOT + safe trimming (Advanced)
Solution: Portable tool with Native AOT + safe trimming
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.
0/6
How does P/Invoke and interop with native code work?
How does P/Invoke and interop with native code work? - Knowledge Check
Hands-On: Call a native function and handle errors (Easy)
Solution: Call a native function and handle errors
Hands-On: Wrap a native buffer API safely (Advanced)
Solution: Wrap a native buffer API safely
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.
0/6
How do MSBuild and SDK-style csproj files work?
How do MSBuild and SDK-style csproj files work? - Knowledge Check
Hands-On: Create a library with SDK-style csproj and pack it to NuGet (Easy)
Solution: Create a library with SDK-style csproj and pack it to NuGet
Hands-On: Customize build pipeline: add code generation and multi-targeting (Advanced)
Solution: Customize build pipeline: add code generation and multi-targeting
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).
0/6
How do you create and version NuGet packages?
How do you create and version NuGet packages? - Knowledge Check
Hands-On: Create a NuGet package with README, icon, and prerelease version (Easy)
Solution: Create a NuGet package with README, icon, and prerelease version
Hands-On: CI-friendly versioning and publishing (Advanced)
Solution: CI-friendly versioning and publishing
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?
0/6
What deployment options exist (IIS, containers, Azure)?
What deployment options exist (IIS, containers, Azure)? - Knowledge Check
Hands-On: Deploy a published ASP.NET Core app to IIS (Windows) (Easy)
Solution: Deploy a published ASP.NET Core app to IIS (Windows)
Hands-On: Containerize and deploy to Azure Container Apps with autoscaling (Advanced)
Solution: Containerize and deploy to Azure Container Apps with autoscaling
C#/.NET Interview Mastery: Hands-On Edition (2026) 
using System;
using System.Collections.Generic;
using System.Linq;

public static class TokenInternDemo
{
    public static void Main()
    {
        // new string(...) binds to the string(ReadOnlySpan<char>) constructor, so each of these
        // is a fresh instance built at run time, not the compiler's interned literal.
        var tokens = new[] { "GET", new string("POST"), new string("GET"), "PUT", new string("GET") };

        // ReferenceEqualityComparer has been in System.Collections.Generic since .NET 5.
        // Do not hand-roll one: a home-made comparer that compares references but hashes
        // contents is inconsistent by construction, and the name shadows the BCL type.
        int before = tokens.Distinct(ReferenceEqualityComparer.Instance).Count();

        for (int i = 0; i < tokens.Length; i++)
            tokens[i] = string.Intern(tokens[i]);

        int after = tokens.Distinct(ReferenceEqualityComparer.Instance).Count();

        Console.WriteLine($"Before refs: {before}, After refs: {after}");
        Console.WriteLine(object.ReferenceEquals(tokens[0], tokens[2]));
        Console.WriteLine(object.ReferenceEquals(tokens[0], tokens[4]));
        Console.WriteLine(string.IsInterned(new string("GET")) is not null);
        Console.WriteLine(string.IsInterned(Guid.NewGuid().ToString()) is null);
    }
}

Output (.NET 10, deterministic):

Before refs: 5, After refs: 3
True
True
True
True

Five values, five distinct references before interning and three after: the three "GET" entries collapse onto one instance, which is the literal the compiler already placed in the pool. The last two lines are the reason the exercise insists on runtime-built strings: a value equal to a live literal is found in the pool, and a fresh high-cardinality value is not, which is exactly why you never intern user input.

Previous
Next
0% Complete