Introduction to Concurrency in C# – Async and Paralellism

Course Curriculum

Chapter 1: Introduction – Basic Concepts

Lecture 1: Introduction

Lecture 2: What is Concurrency?

Lecture 3: Introduction to Parallel Programming

Lecture 4: Introduction to Asynchronous Programming

Lecture 5: CPU vs I/O Bound Operations

Lecture 6: Sequential Programming, Concurrency, Multi-threading, Parallelism, Multi-tasking

Lecture 7: Determinism vs Non-Determinism

Lecture 8: Preparing the Development Environment

Lecture 9: Source Code of the Course

Lecture 10: Conclusion

Chapter 2: Asynchronous Programming

Lecture 1: Introduction

Lecture 2: async-await

Lecture 3: Creating the Project

Lecture 4: Non-Freezing UI

Lecture 5: Task

Lecture 6: Task That Returns a Value

Lecture 7: Tasks with Errors

Lecture 8: Executing Multiple Tasks – Task.WhenAll

Lecture 9: Offloading the Current Thread – Task.Run

Lecture 10: Limiting the Amount of Concurrent Tasks – SemaphoreSlim

Lecture 11: Using the Response Task.WhenAll

Lecture 12: Reporting Progress with IProgress

Lecture 13: Reporting Progress in Intervals – Task.WhenAny

Lecture 14: Cancelling Tasks

Lecture 15: Cancelling Loops

Lecture 16: Cancelling with a Timeout

Lecture 17: Creating Finished Tasks – Task.FromResult and Friends

Lecture 18: Using the Same Thread – SynchronizationContext

Lecture 19: Ignoring the SynchronizationContext – ConfigureAwait

Lecture 20: Retry Pattern

Lecture 21: Only-One Pattern

Lecture 22: Controlling the Result of a Task – TaskCompletionSource

Lecture 23: Cancelling Non-Cancellable Tasks with TaskCompletionSource

Lecture 24: Understanding and Consuming ValueTask

Lecture 25: Conclusion

Chapter 3: Asynchronous Streams

Lecture 1: Introduction

Lecture 2: Reviewing IEnumerable and yield

Lecture 3: Asynchronous Streams

Lecture 4: Cancelling Asynchronous Streams

Lecture 5: Cancelling Through IAsyncEnumerable – EnumeratorCancellation

Lecture 6: Conclusion

Chapter 4: Antipatterns in Asynchronous Programming

Lecture 1: Introduction

Lecture 2: Deadlocking the App – sync-over-async

Lecture 3: async-over-sync

Lecture 4: Highly Dangerous – async void

Lecture 5: Avoid Task.Factory.StartNew

Lecture 6: Dispose CancellationTokenSource

Lecture 7: Correctly Dispose Streams

Lecture 8: Conclusion

Chapter 5: Parallelism

Lecture 1: Introduction

Lecture 2: Parallelism Review

Lecture 3: Simultaneous Tasks – Task.WhenAll

Lecture 4: Understanding Parallel.For

Lecture 5: Parallel.For – Speed Improvement

Lecture 6: Task.WhenAll vs Parallel.For

Lecture 7: Iterating Collections – Parallel.ForEach

Lecture 8: Speed Benefits

Lecture 9: Parallelizing Different Methods – Parallel.Invoke

Lecture 10: Cancelling Parallel Operations

Lecture 11: Maximum Degree of Parallelism

Lecture 12: Atomic Methods

Lecture 13: Thread-Safe

Lecture 14: Race Conditions

Lecture 15: Updating a Variable Atomically – Interlocked

Lecture 16: One Thread at a Time – Locks

Lecture 17: Each Thread Gets One – ThreadStatic

Lecture 18: Introduction to PLINQ

Lecture 19: Doing Aggregates in PLINQ

Lecture 20: Processing as Soon as it is Ready – ForAll

Lecture 21: Conclusion

Chapter 6: Parallelism Antipatterns

Lecture 1: Introduction

Lecture 2: Unnecessary Parallelism

Lecture 3: Race Conditions

Lecture 4: Too Much Can Be Bad – Oversaturation

Lecture 5: Using a Non-Thread-Safe Class

Lecture 6: Misuse of Locks

Lecture 7: Conclusion