Mastering: C#

Source: https://dometrain.com/course/mastering-csharp/

To write highly performant C# applications, you need a precise understanding of how the compiler and runtime handle your code. This course is a comprehensive breakdown of C# execution semantics and memory management, built up from the compilation pipeline. You will start with multi-targeting, TFMs, and using PolySharp to enable modern features like init-only and required properties on legacy frameworks. From there, we explore the exact storage models, memory layouts, and access patterns of value types versus reference types. You will examine object construction order, the dangers of virtual calls in base constructors, and the performance implications of the new() constraint. We then look at structs and records under the hood, focusing on boxing, avoiding defensive copies, the readonly field trap, and the mechanics of value-based equality. You will also learn when to use System.ValueTuple versus custom union types, how to analyze hidden boxing allocations in ThrowIfNull, and how to properly structure multi-targeted extension methods.

The second half of the course focuses heavily on delegates, pattern matching, and iterators. You will profile closure allocations in lambda expressions, compare method group conversions to lambdas, and examine scope-based code generation alongside .NET 10 delegate de-abstraction. We then cover declarative code using recursive patterns and exhaustiveness checks across open and closed hierarchies. Finally, you will thoroughly dismantle LINQ and iterator blocks. By analyzing the lowered C# code, you will see exactly how the compiler generates state machines, measure the allocation costs of boxed iterators, and use static analysis to prevent multiple enumerations of IEnumerable. The course concludes with a rigorous look at LINQ performance, teaching you how to optimize data pipelines using spanification, type-based specialization, iterator fusion, fast path overrides, and vectorization.