Mastering: C#

article المحتوى

Learn how C# features work under the hood, from the memory layout of types to the performance of lambdas, pattern matching, and LINQ.

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.

Table of Contents
1 Welcome
2 What will you learn in this course
3 Who is this course for and prerequisites
4 Overview
5 Working on legacy projects.
6 The compilation pipeline
7 Multi-targeting
8 Adding multi-targeting
9 What is target framework moniker (TFM).
10 C# Language version vs. Target framework
11 Using init-only and required properties in .NET Framework
12 Compiler language specific types
13 PolySharp- source-only polyfills for C# Language
14 Using PolySharp for init-only and required properties
15 Choosing the right C# Language version
16 ‘latest’ vs. specific C# Language version
17 Using Directory.Build.props
18 Conclusion
19 Module Overview
20 Overview
21 Storage Model- Inline vs. Indirection
22 Exploring Storage
23 Analyzing Storage Model with Benchmarks
24 Inspecting Type Layout (part 2)
25 Exploring Access Patterns with Benchmarks
26 Analyzing Access Patterns Benchmark Results
27 Copy Semantics- Assignment
28 Copy Semantics- Parameter Passing
29 Equality Semantics
30 Summary
31 Overview
32 Object Initialization
33 Analyzing Object Construction Order
34 Virtual Calls in the Base class Constructor
35 Using Analyzers to Avoid Making Virtual Calls in Base Constructors
36 A Custom Factory Method and Error Handling
37 Exploring a Custom Factory Method Behavior at Runtime
38 Benchmarking the new() Constraint
39 Conclusion
40 Overview
41 Boxing and Indexers
42 Exploring Different Kind of Copies
43 The Readonly Field Trap
44 Why the Compiler Makes a Copy.
45 How to Avoid Defensive Copies for Structs.
46 Defensive Copy Overview
47 Conclusion
48 Overview
49 Manual Value-based Equality
50 Referential and Value-based Equality
51 Records Under the Hood
52 Records Limitations
53 Issues With the Default Structs Equality
54 Record Structs vs. Default Structs
55 Overview
56 System.Tuple vs. System.ValueTuple
57 Tuples in C#
58 Knowing the Limits- When to Move to Actual Types
59 Union Types- Why Do We Need Them.
60 Union Types- the Basics
61 Union Types Under the Hood
62 Union Types- the Deep Dive
63 UnionTypes – Recap
64 Conclusion
65 Section Overview
66 Overview
67 Argument Validation and Nullable Reference Types
68 Argument Null Checks in C#
69 Checking for Null in C#
70 Recreating ThrowIfNull Manually
71 Analyzing ThrowIfNull Boxing Allocations
72 Issues With Nullable Strings in .NET Framework
73 Implementing Custom String Validation
74 Summary
75 Overview
76 Extension Methods
77 Refactoring to Extension Everything
78 The issue with Multi-Targeting
79 Creating Polyfills for Argument Validation
80 Extending the C# Language
81 Summary
82 Overview
83 Lambdas Are Ubiquitous
84 Lambdas Under the Hood
85 Benchmarking Lambda Expressions
86 Profiling Closure Allocations
87 .NET 10 Delegate De-Abstraction
88 Scope-based Code Generation for Lambda Expressions
89 Issues With Capturing Loop Variables
90 Method Group Conversion vs. Lambda Expressions
91 Method Group Conversion vs. Lambda Expressions in Action
92 Overview
93 Imperative vs. Declarative Code
94 Exploring Pattern Matching Variety
95 Two Dimensions of Pattern Matching
96 Recursive Patterns Explained
97 Pattern Matching Exhaustiveness
98 Exhaustiveness Checks in Action
99 Open and Closed Hierarchies
100 Exhaustiveness Checks for Classes and Unions
101 Know When to Stop
102 Section Overview
103 Overview
104 Iterator Design Pattern in C#
105 Iterator as a State Machine
106 Foreach Under the Hood
107 Foreach and IEnumerable
108 The Cost of Boxed Iterators
109 Enumerable De-Abstraction in .NET 10
110 Iterator as a Mutable Struct
111 Summary
112 Overview
113 Manual Iterator Implementation
114 Refactor To Use Iterator Blocks
115 Iterator Block Execution Semantics
116 Lowered C# Code for Generated State Machines
117 State Machine Under the Hood
118 State Machine Allocations
119 Benchmarking State Machine Allocations
120 De-Abstracting Iterator Blocks in .NET 10
121 Error Handling in Iterator Block
122 Resources in Iterator Blocks
123 Overview
124 Two Syntaxes, One Model
125 Query Comprehensions vs. Method Calls
126 What Is IEnumerable-T-
127 Multiple Enumerations with IEnumerable-T-
128 LINQ Deferred Execution Model
129 Using Static Analysis to Avoid Multiple Enumerations
130 Summary
131 Overview
132 LINQ Performance Reputation
133 Performance Optimization Loop
134 Mastering LINQ Performance
135 LINQ vs. Manual Loop Performance Analysis
136 Analyzing Enumerable.Any Performance
137 Spanification in LINQ
138 LINQ Performance Improvements in .NET 10
139 LINQ Performance Optimization Patterns
140 Type-based Specialization
141 Iterator Fusion
142 Iterator Fast Path Overrides
143 For loop vs. Enumerable.SequenceEquals
144 Vectorization in .NET Framework
145 Summary
146 Conclusion