C 10 Pocket Reference Instant Help for C 10 Programmers (Joseph Albahari, Ben Albahari)（Z-Library）

# C# 10 Pocket Reference: Instant Help for C# 10 Programmers ## 【One-Line Pitch】 A tightly focused, browseable reference for experienced developers (Java, C++, or earlier C#) who need quick answers on C# 10 syntax, types, and advanced features without lengthy tutorials or bloated examples. ## 【Book Arc】 - **Opening (~0%–10%)**: Establishes C# fundamentals—program structure, methods, compilation into assemblies, and the core distinction between value types (which copy on assignment) and reference types. - **Early (~10%–23%)**: Dives into the type system: numeric types with their ranges and suffixes, special floating-point values (NaN, infinity), string immutability, arrays with ranges and indices, and parameter passing mechanics (by value, ref, out, in). - **Early (~23%–32%)**: Covers modern C# syntax conveniences—named and optional arguments, `var` for implicitly typed locals, null-conditional operators, and the evolution of switch statements into pattern-matching switch expressions. - **Middle (~39%–48%)**: Moves into class design: constants vs. static readonly fields, method signatures and expression-bodied methods, object initializers, the `this` reference, init-only properties for immutability, indexers, and partial methods for code generation hooks. - **Late (~48%–end)**: Extends into inheritance and type testing with `as` and `is` operators, plus the book's coverage of advanced topics including operator overloading, nullable types, closures, patterns, async functions, LINQ, unsafe code, and XML documentation (per the publisher's description). ## 【Key Takeaways】 - **Value types copy on assignment** (Early): Understanding this fundamental distinction prevents subtle bugs—changing `p1.X` after `Point p2 = p1` leaves `p2` untouched, unlike reference types where both variables see the same object. - **8- and 16-bit integers lack arithmetic operators** (Early): C# implicitly promotes `short`, `byte`, etc. to `int` for operations, so `short z = x + y` fails to compile—you need an explicit cast back, a common gotcha for newcomers. - **Floating-point has special values** (Early): `double.NaN`, `PositiveInfinity`, and `NegativeInfinity` behave differently from integral types—dividing by zero yields infinity rather than throwing, which matters for numerical code. - **Strings are immutable reference types with value semantics** (Early): `string` equality uses `==` to compare content, not reference identity, and escape sequences work inside string literals—essential for text processing. - **`var` is statically typed, not dynamic** (Early): `var x = 5; x = "hello"` fails at compile time because the compiler infers `int`—this is syntactic sugar, not a relaxation of type safety. - **Null-conditional operators chain safely** (Early): `sb?.ToString()?.Length` short-circuits to null rather than throwing `NullReferenceException`, and combines naturally with `??` for defaults—critical for defensive coding. - **Switch expressions enable concise pattern matching** (Early): From C# 8, `cardNumber switch { 13 => "King", _ => "Pip card" }` replaces verbose if-chains, with `when` clauses adding conditions and type patterns enabling object matching. - **Init-only properties enable immutable classes** (Middle): Unlike settable properties, `init` accessors allow object initializer syntax while keeping the object immutable afterward—a versioning-friendly alternative to constructor parameters. ## 【Reading Tips】 - **Skim the opening chapters** (~0%–10%) if you already know Java or C++—the value/reference type distinction and method syntax will be familiar; focus instead on C#-specific details like the `nint` type and overflow checking. - **Deep-read the parameter passing section** (~19%–23%): The `ref`, `out`, and `in` modifiers table is worth memorizing, and the examples showing how reference types behave when passed by value are subtle but crucial. - **Pay special attention to the switch expression examples** (~29%–32%): These show modern C# idioms you'll encounter in real codebases—type patterns, `when` guards, and the discard `_` pattern are all here. - **Use the book as a lookup tool, not a cover-to-cover read**: The pocket reference format means each section is self-contained—jump to the topic you need (e.g., "Indexers" or "Partial methods") when writing code. - **Try the LINQPad samples** mentioned in the introduction: Since code snippets are interactive, you can experiment with the type system behaviors (like the `short` arithmetic error) without setting up a full Visual Studio project. ## 【Coverage Limits】 This guide synthesizes excerpts covering roughly the first half of the book (fundamentals through class design and inheritance). The publisher's description indicates later sections cover LINQ, unsafe code, attributes, and XML documentation, but those topics are not detailed in the available source material. ##