Parallel Programming with C and .NET Fundamentals of Concurrency and Asynchrony Behind Fast-Paced Applications (Vaskaran Sarcar)（Z-Library）

【One-Line Pitch】 A practical, example-driven guide for C# developers who want to move from theory to working code in parallel and asynchronous programming, covering the Task Parallel Library, synchronization, concurrent collections, and async/await with .NET 8 and C# 12. 【Book Arc】 - **Opening (~0%–9%)**: Sets the stage with the book's philosophy—there's "no royal road" to parallel programming—and introduces the core toolkit: TPL, Tasks, Concurrent Collections, PLINQ, and async/await. It frames the reader as a C# developer who is new to concurrency and warns against quick-fix learning. - **Early (~9%–25%)**: Dives into Task fundamentals: five ways to create and start tasks, passing values (including the boxing trade-off), retrieving results via `Task<T>.Result`, and chaining work with `ContinueWith` and `TaskContinuationOptions` (e.g., `OnlyOnRanToCompletion`, `OnlyOnCanceled`). Also covers waiting patterns like `WaitAll` and `WaitAny`. - **Early–Middle (~25%–38%)**: Handles special scenarios: exception handling with `AggregateException` (single vs. multiple locations), cancellation via `CancellationTokenSource`, and the `TaskCompletionSource<T>` pattern for bridging async and sync code. Includes exercises that clarify subtle behaviors, such as why `WaitAny` doesn't propagate exceptions. - **Middle (~38%–47%)**: Explores synchronization and concurrent collections. Starts with a non-synchronized bank account example showing race conditions, then moves to thread-safe types in `System.Collections.Concurrent`: `ConcurrentStack<T>`, `ConcurrentQueue<T>`, `ConcurrentDictionary<TKey,TValue>`, `ConcurrentBag<T>`, and `BlockingCollection<T>`, plus the `IProducerConsumerCollection<T>` interface. - **Late (~47%–100%)**: Covers parallel loops (e.g., `Parallel.For`, `Parallel.ForEach`) to speed up CPU-bound work, PLINQ for declarative parallel queries, and finally async/await—including state machines behind the scenes, the difference between `Task.Run` and `Task.Factory.StartNew`, and unwrapping nested tasks with `Unwrap` or `await`. Ends with exercises and solutions. 【Key Takeaways】 - **Tasks are the foundation of concurrency** (Early): Five creation patterns (e.g., `new Task`, `Task.Run`, `Task.Factory.StartNew`) each have trade-offs—passing `object` to methods causes boxing/unboxing, while lambdas are cleaner but less explicit. Choose based on clarity vs. performance. - **Continuations give you fine-grained control** (Early): `ContinueWith` with `TaskContinuationOptions` (e.g., `OnlyOnRanToCompletion`, `OnlyOnCanceled`) lets you attach success/cancel handlers, making task status explicit and reducing manual checks. - **Exceptions in tasks are aggregated, not thrown directly** (Early–Middle): `AggregateException` wraps all failures; use `ae.Handle()` to filter and process them in one place or propagate up the call stack. This avoids crashing the app and centralizes error logic. - **Cancellation is cooperative, not forceful** (Early–Middle): Use `CancellationTokenSource` and check the token inside the task; throwing `OperationCanceledException` is a clean way to signal cancellation, and the task's status becomes `Canceled` rather than `Faulted`. - **`WaitAny` has different exception semantics** (Middle): Unlike `Wait` and `WaitAll`, `WaitAny` does not propagate the first task's exception into an `AggregateException`—you must inspect task statuses after it returns, which is a common gotcha. - **Concurrent collections are purpose-built for high concurrency** (Middle): `ConcurrentDictionary<TKey,TValue>` is the only one that allows key-based access to any item (via `TryPeek` or indexing), while `ConcurrentStack`, `ConcurrentQueue`, and `ConcurrentBag` only peek one item deep. `BlockingCollection<T>` wraps any `IProducerConsumerCollection<T>` for producer/consumer scenarios. - **Async/await hides the complexity of state machines** (Late): The compiler generates state machines behind the scenes; understanding this helps you debug and optimize. `Task.Run` treats sync and async lambdas uniformly, while `Task.Factory.StartNew` does not—use `Unwrap` or `await` to flatten nested tasks. 【Reading Tips】 - **Skim the Q&A and "Points to Remember" boxes** (Early–Middle): These distill key insights (e.g., C# 12 collection expressions, `WaitAny` semantics) that are easy to miss in code-heavy sections. - **Deep-read Chapter 1 for task creation and continuations** (Early): This is the bedrock; get comfortable with all five creation approaches and `TaskContinuationOptions` before moving on, as later chapters assume this knowledge. - **Run the bank account example yourself** (Middle): The non-synchronized version produces inconsistent outputs—seeing this live makes the case for `lock` or concurrent collections much more concrete than reading about it. - **Treat exercises as mini-labs** (Middle–Late): Exercises like E2.7 and E2.8 reveal subtle behaviors (e.g., `WaitAny` not throwing) that are easy to overlook; attempt them before checking solutions to solidify understanding. - **Don't skip the async/await chapter's state machine section** (Late): It's the most theoretical part, but it explains why `async` methods behave the way they do—crucial for debugging real-world code. 【Coverage Limits】 This guide covers the book's core progression through Tasks, special scenarios, synchronization, concurrent collections, and async/await. It does not detail PLINQ operators or parallel loop internals in depth, as the excerpts focus on earlier chapters; readers should consult the book for those late-stage topics.