Fundamentals
Syntax, Types & Control Flow beginner Learn the difference between value types (int, double, decimal, bool, char, struct) and reference types (string, class, object). Nullable value types (int?) prevent null reference errors at the type level. Master string interpolation, raw string literals, and verbatim strings. Use switch expressions instead of switch statements, and var for obvious types.
8h Fundamentals
Classes, Structs & OOP beginner Classes are reference types, structs are value types — this distinction matters for performance and semantics. Learn constructors, properties (auto, init-only, required), and access modifiers. Understand inheritance, abstract classes, and interfaces with default implementations. Use sealed to prevent unwanted inheritance and partial for splitting large classes. Object initializers and with expressions simplify construction.
10h Fundamentals
Collections & Generics beginner Never use ArrayList — always use generic collections. List<T>, Dictionary<TKey,TValue>, HashSet<T>, Queue<T>, and Stack<T> are your everyday tools. Understand IEnumerable<T> and ICollection<T> interfaces. Generic classes, methods, and constraints (where T : class, struct, new(), IComparable<T>) enforce type safety. Covariance (out) and contravariance (in) matter for interface flexibility.
10h Core
Exceptions & Resource Management intermediate Use try/catch/finally with exception filters (when clause) for precise error handling. Implement IDisposable for deterministic resource cleanup — the using statement and using declarations ensure Dispose is called. Never catch Exception unless you rethrow — use throw, not throw ex, to preserve stack traces. Build custom exception types for domain-specific errors.
8h Core
LINQ & Functional Patterns intermediate LINQ is one of C#'s most powerful features. Master both query syntax (from, where, select) and method syntax (Where, Select, SelectMany, GroupBy, Join, OrderBy, Aggregate). Understand deferred execution — LINQ queries don't run until you iterate. Learn lambda expressions, delegates (Func<>, Action<>, Predicate<>), and events. Expression trees power IQueryable for database translation.
12h Core
Async/Await & Task-Based Patterns intermediate async/await compiles to a state machine — understanding this prevents common pitfalls. Use Task and Task<T> for async operations. ConfigureAwait(false) avoids deadlocks in library code. Task.WhenAll and Task.WhenAny handle concurrent operations. ValueTask reduces allocations on hot paths. CancellationToken patterns enable cooperative cancellation. IAsyncEnumerable supports async streaming. Never use async void except for event handlers.
12h Intermediate
Pattern Matching & Modern Syntax intermediate C# pattern matching goes far beyond simple type checks. Use is patterns for type testing, switch expressions for exhaustive matching, property patterns for nested checks, relational patterns for range comparisons, and list patterns for sequence matching. Combine patterns with and/or/not for complex conditions. Pattern matching often replaces polymorphism for operations that cross type hierarchies.
8h Advanced
Records, Tuples & Spans advanced Records give you value equality, immutability, and with-expressions for non-destructive mutation. Record struct combines value semantics with record features. Tuples and deconstruction patterns simplify returning multiple values. Span<T> and Memory<T> enable zero-allocation slicing of arrays and strings — essential for high-performance code. Use ref returns and ref locals for avoiding copies of large value types.
10h Advanced
Delegates, Events & Reflection advanced Delegates are type-safe function pointers — multicast delegates chain multiple handlers. Events build on delegates with publisher-subscriber patterns using EventHandler<T>. Attributes (built-in and custom) add metadata to code. Reflection inspects and invokes types at runtime — powerful but slow. Expression trees represent code as data for metaprogramming. Source generators analyze code at compile time without runtime cost.
10h Production
Advanced Patterns & Performance advanced Extension methods let you add functionality to types you don't own — use them to build clean, fluent APIs. Implement IEquatable<T> and IComparable<T> for proper equality and sorting. Enable nullable reference types project-wide and treat warnings as errors. Use global usings and file-scoped namespaces to reduce ceremony. Benchmark with BenchmarkDotNet before optimizing — measure, don't guess.
10h 