C 12 Pocket Reference (Joseph Albahari, Ben Albahari) (Z-Library)

【One-Line Pitch】 A compact, no-fluff reference for C# 12 that gets you up to speed fast if you already know Java, C++, or an earlier C# version—ideal for quick lookups and hands-on practice with LINQPad samples. 【Book Arc】 - **Opening (~0%–10%)**: Introduces C# 12 as a type-safe, object-oriented language built for .NET 8, then covers the absolute basics: reserved keywords (and how to escape them with `@`), contextual keywords, and the symmetry between predefined types (like `int`) and custom types (like a `UnitConverter` class). This stage solves the "where do I start?" problem by grounding you in syntax and type fundamentals. - **Early (~10%–23%)**: Dives into numeric types (int, double, decimal, float), including literal inference, suffixes, and special values like NaN and infinity—plus the critical `double` vs `decimal` distinction for scientific vs financial work. Then moves to strings: escape sequences, verbatim literals (`@"..."`), and raw string literals (`"""..."""`) for JSON/XML. This stage builds your data-handling toolkit. - **Early (~23%–32%)**: Covers variables and parameters in depth: passing by value vs by reference (`ref`), implicitly typed variables (`var`), and target-typed `new` expressions (C# 9+). Then shifts to operators and control flow—switch expressions (including tuple switching), and iteration statements like `while`, `do-while`, `for`, and `foreach`. This stage makes you fluent in everyday C# syntax. - **Early (~32%–39%)**: Explains namespaces (hierarchical, independent of assemblies) and classes—the core reference type. Covers class modifiers, fields (including `readonly`), constructors (including nonpublic ones for controlled instantiation), and deconstructors (C# 7+) that reverse constructor logic. This stage is the heart of object-oriented C#. - **Middle (~39%–48%)**: Explores advanced class features: primary constructors (C# 12) with their limitations, partial types and methods for splitting definitions across files (great for autogenerated code), and inheritance—upcasting/downcasting, reference conversions, and sealing functions/classes. Also covers boxing/unboxing and struct construction semantics, including the implicit parameterless constructor and `default` keyword. This stage rounds out your OOP mastery. 【Key Takeaways】 - **Keywords and identifiers** (Early): Reserved keywords can be used as identifiers with the `@` prefix (e.g., `@class`), and contextual keywords (like `record`) don't need it. This saves you from naming headaches in real code. - **Numeric literal rules** (Early): Literals with a decimal point or `E` are `double`; otherwise, the compiler picks the first fitting type from `int`, `uint`, `long`, `ulong`. Suffixes like `M` for `decimal` give explicit control—critical for precision-sensitive code. - **Special float/double values** (Early): NaN, +∞, −∞, and −0 behave unexpectedly: NaN never equals itself with `==` (use `double.IsNaN`), but `object.Equals` treats two NaNs as equal. This prevents subtle bugs in scientific computing. - **String literal options** (Early): Verbatim strings (`@"..."`) avoid backslash escaping, and raw string literals (`"""..."""`) handle JSON/XML/regex without escaping at all—huge for readability in modern C#. - **Passing by reference** (Early): The `ref` modifier makes parameters share memory with the caller's variable, so changes persist. Without it, reference types copy the reference (not the object), so setting a parameter to `null` doesn't affect the original—a common source of confusion. - **Target-typed `new`** (Early): `StringBuilder sb = new();` infers the type from the declaration, reducing repetition, especially when initializing fields in constructors. It's a C# 9+ feature that makes code cleaner. - **Primary constructors (C# 12)** (Middle): They simplify simple classes but have limits—no extra initialization code, and validation logic is hard unless properties are read-only. They also displace the default parameterless constructor, so use them deliberately. - **Struct construction semantics** (Middle): Even with custom parameterless constructors (C# 11+), the implicit one still exists via `default`, which bitwise-zeroes fields. This lets you bypass initializers—useful for arrays and performance-sensitive scenarios. 【Reading Tips】 - **Skim the keyword lists and operator tables** (Early): These are reference material, not prose—scan them when you need a quick lookup, don't read them cover-to-cover. - **Deep-read the numeric and string sections** (Early): These have subtle rules (NaN, literal inference, raw strings) that trip up even experienced devs. Work through the LINQPad samples to see results instantly. - **Focus on the `ref` and `var` examples** (Early): They're short but dense; trace through the code mentally to internalize how memory and type inference work. - **Pay extra attention to primary constructors and partial types** (Middle): These are newer C# features with specific trade-offs—understand their limitations before using them in production. - **Use the book as a lookup, not a tutorial**: It's a pocket reference, so jump to the section you need (e.g., "Inheritance" for casting rules) rather than reading sequentially. 【Coverage Limits】 This guide covers the core language up to structs and inheritance, but the excerpts don't include later chapters on records, tuples, LINQ, or async/await—those are beyond the sampled material.