C Concurrency Asynchronous and multithreaded programming (Nir Dobovizki)（Z-Library）

# C# Concurrency: Asynchronous and Multithreaded Programming — Reading Guide ## 【One-Line Pitch】 A practical, hands-on guide for experienced C# developers who want to master async/await, multithreading, and thread-safe code without falling into the classic deadlocks and performance traps. If you write C# for a living and concurrency still feels like magic or misery, this book is your translator. ## 【Book Arc】 - **Opening (~0%–9%)**: Sets the stage with why concurrency matters today—CPU speeds have plateaued, cloud computing bills reward efficiency, and multicore processors demand parallel thinking. The author uses a kitchen/pizza analogy to distinguish asynchronous (waiting for the oven to beep) from multithreaded (hiring more cooks) approaches. - **Early (~9%–25%)**: Builds foundational knowledge: lambda functions and how the compiler transforms them, the thread pool, and the core mechanics of async/await. The famous BMP file-reading example walks through converting synchronous code to asynchronous step by step. - **Early–Middle (~25%–38%)**: Dives deep into Task and Task<T>, including how the compiler rewrites async methods into state machines, error handling with IsFaulted/IsCanceled, and the ValueTask<T> optimization for methods that often return immediately without async work. - **Middle (~38%–47%)**: Explores explicit multithreading with the Thread class, Thread.Join for parallel work, and Task.Run for thread-pool execution. Covers the critical distinction between awaiting (which defeats the purpose) and fire-and-forget patterns, plus the warning-suppression discard pattern. - **Middle (~47%–end)**: Tackles the hard problems: shared mutable state, immutable data as a solution, thread-safe collections (ConcurrentDictionary, BlockingCollection, ConcurrentQueue/Stack/Bag), and when to use—or avoid—each concurrency primitive. ## 【Key Takeaways】 - **Async/await is compiler magic, not runtime magic** (Early): The compiler transforms your linear-looking code into a state machine with callbacks. Understanding this transformation—as shown with the BMP example—explains why code before the first await runs synchronously and why exceptions behave differently. This mental model prevents most async confusion. - **Task.Result and .Wait() are deadlock bait** (Early): Blocking on an async operation can freeze your program in UI or ASP.NET contexts. The book shows safer patterns for integrating async with sync code, and why checking IsFaulted/IsCanceled after completion is the proper way to handle task outcomes. - **ValueTask<T> is the performance scalpel** (Middle): When a method often returns a value without actually doing async work (like a cache hit), ValueTask<T> avoids allocating a full Task object. Use it for hot paths that frequently complete synchronously—but accept it's slightly less efficient when real async work happens. - **Task.Run without await is fire-and-forget, and that's often correct** (Middle): Awaiting Task.Run makes your code sequential, defeating the purpose. The discard pattern (`_ = Task.Run(...)`) silences warnings while preserving true background execution. The exception: UI threads, where awaiting is sometimes necessary. - **Immutable shared data eliminates entire bug classes** (Middle): If no thread ever modifies shared data, you can't have race conditions. While functional-style immutability isn't typical C#, the book argues it's technically excellent—just requires a different coding mindset. - **Regular collections are not thread-safe, period** (Late): Dictionary, List, and friends will corrupt or crash under concurrent access. The concurrent collections (ConcurrentDictionary, BlockingCollection, ConcurrentQueue/Stack/Bag) exist for specific scenarios, and the book covers when each fits—and when they're overkill. - **Know when NOT to use concurrency** (Throughout): Cloud computing makes throwing hardware at problems tempting, but efficiency saves real money. The book consistently asks: is this actually faster with threads, or just more complex? ## 【Reading Tips】 - **Deep-read Chapter 3** (the async/await chapter): The BMP example and the state-machine transformation are the heart of the book. If you understand why the compiler splits your method at each await, everything else clicks. - **Skim the lambda-function chapter** if you're already comfortable with closures; the compiler-transformation details matter more for understanding async than for daily lambda use. - **Pay special attention to the "when not to use" sections**—they're rare in concurrency books and save you from over-engineering. The author's 30 years of experience shows in these judgment calls. - **The thread-safe collections chapter (13) is reference material**: Don't memorize it; bookmark it. When you hit a concurrency bug, come back and match your scenario to the right collection. - **Code along with the examples**: The book's value is in the patterns, not the prose. Type out the BMP reader, the Task.Run discard pattern, and the thread-joining examples to internalize them. ## 【Coverage Limits】 This guide covers the book's core progression through async/await, Task/ValueTask, threading, and thread-safe collections. The excerpts do not cover the later chapters on exception handling in async methods, advanced synchronization primitives (locks, semaphores, etc.), or the UI-thread specifics mentioned but not detailed in the sampled material. ##