Skip to main content
CF

Async Expert

33h 11m 40s
English
Paid
Added to CourseFlix

Async Expert is a 86-lesson 33 hours 11 minutes self-paced course by Konrad Kokosa, Szymon Kulec, Łukasz Pyrzyk. Asynchronous code in .

Course facts

Lessons
86
Duration
33 hours 11 minutes
Language
English
Added to CourseFlix
July 2025
Instructor
Konrad Kokosa, Szymon Kulec, Łukasz Pyrzyk
Price
Premium

Asynchronous code in .NET is easy to write badly and hard to debug well. Async Expert, taught by Konrad Kokosa, Szymon Kulec, and Łukasz Pyrzyk, takes the subject from first principles through to the details that trip up experienced developers.

What's Covered

  • The mechanics of async-await and how the runtime actually schedules work
  • Working safely with concurrent collections
  • Managing parallelism without introducing subtle bugs

Extra Material

Across 86 lessons, homework assignments reinforce each topic, and the course includes guest material from recognized .NET experts Marc Gravell, Daniel Marbach, and Stephen Cleary. The collection has also been extended with the separate C# 9.0 Professional course.

Update: It was decided to also add the course C# 9.0 Professional to the collection.

Additional

https://github.com/dotnetos/AsyncExpert-Course

Who teaches Async Expert?

Konrad Kokosa

Konrad Kokosa thumbnail

Konrad Kokosa is a Polish .NET specialist and the author of Pro .NET Memory Management (Apress) — the canonical reference work on the CLR memory model and garbage collector. He runs Dotnetos, a .NET training company focused entirely on the deep performance side of the platform.

His CourseFlix listing carries two Konrad Kokosa courses: .NET Memory Expert and Async Expert. Material is paid and aimed at senior .NET engineers working on performance-critical applications who need to understand the CLR at the level the framework hides from most developers.

Szymon Kulec

Szymon Kulec thumbnail

Szymon Kulec is a Polish .NET engineer (Microsoft MVP) and one of the contributors to the Async Expert course on advanced .NET asynchronous programming, alongside Konrad Kokosa and Łukasz Pyrzyk on the Dotnetos training platform.

His CourseFlix listing carries Async Expert — a deep dive into the async/await model in .NET, covering the synchronisation context, ConfigureAwait, the thread-pool interactions, and the production-debugging patterns for async-heavy code.

Material is paid and aimed at senior .NET developers working on performance-critical applications where the async model needs to be understood at the level of the runtime rather than the language surface.

Łukasz Pyrzyk

Łukasz Pyrzyk thumbnail

Łukasz Pyrzyk is a Polish .NET engineer and one of the contributors to the Async Expert course on advanced .NET asynchronous programming. He works alongside Konrad Kokosa and Szymon Kulec on the Dotnetos training platform, focused entirely on the deep performance side of .NET.

His CourseFlix listing carries Async Expert — a deep dive into the async/await model in .NET, covering the synchronisation context, ConfigureAwait, the thread-pool interactions, and the production-debugging patterns for async-heavy code.

Material is paid and aimed at senior .NET developers working on performance-critical applications. For broader content, see CourseFlix's C# category page.

What lessons are included in Async Expert?

This is a demo lesson (10:00 remaining)

Watch the first 10 minutes free. One payment unlocks all 86 lessons here and every other premium course. No auto-renew.

Watch all 86 lessons from $6.67/mo
0:00
/
#1: Course overview
All Course Lessons (86)
#Lesson TitleDurationAccess
1
Course overview Demo
05:38
2
BenchmarkDotNet basics
22:33
3
Demo: sharplab.io
10:07
4
Demo: ConcurrencyVisualizer
09:45
5
Demo: Parallel Stacks/Tasks
08:10
6
Homework
01:23
7
Threads
01:42:37
8
ThreadPool
01:37:50
9
Demo: ThreadPool use with different API
20:27
10
Demo: ThreadPool.BindHandle usage
19:36
11
Homework
01:30
12
Task API
01:16:11
13
Async-await foundations
01:55:31
14
Async eliding
19:59
15
ValueTask
23:46
16
Task API and async
27:37
17
Homework
01:06
18
Execution, contexts, scheduler
01:30:08
19
Sync vs async
43:53
20
Fire and forget
17:56
21
TaskCompletionSource
24:45
22
Awaitables
25:36
23
Locals
37:31
24
Homework
01:22
25
Tasks aggregations
45:33
26
IAsyncDiposable
17:39
27
IAsyncEnumerable
15:01
28
Demo: gRPC with IAsyncEnumerable
07:05
29
Demo: New SQL client
03:34
30
Demo: Timeout with WhenAny and WhenAll
05:34
31
Homework
00:46
32
Hardware
40:02
33
volatile
15:41
34
Demo: Epoch programming in ConcurrentQueue
15:09
35
Interlocked
19:39
36
Demo: simple pool with Interlocked.Exchange
03:54
37
Barriers and alignment
09:36
38
Demo: range reservation with Aeron.NET and Interlocked.CompareExchange
10:48
39
Homework
01:08
40
Exclusive locking - part 1
24:13
41
Demo: decompiling lock
06:17
42
Exclusive locking - part 2
09:57
43
Demo: non-blocking usage of Monitor.TryEnter
07:35
44
Exclusive locking - part 03
08:21
45
Non-exclusive locking - part 1
11:07
46
Demo: task throttling with Task and SemaphoreSlim
08:03
47
Non-exclusive locking - part 2
07:38
48
Demo: Building custom string pool with ReaderWriterLock
12:10
49
Non-exclusive locking - part 3
06:09
50
Signalling
13:20
51
Asynchronous primitives - part 1
05:51
52
Demo: AsyncLock implementation
21:33
53
Asynchronous primitives - part 2
15:58
54
Homework
01:10
55
Foundations
20:52
56
BlockingCollection
11:56
57
ConcurrentStack
16:43
58
Demo: object cache with ConcurrentStack
04:11
59
ConcurrentQueue
22:24
60
Demo: memory pool in Kestrel ASP.NET with ConcurrentQueue
07:39
61
ConcurrentDictionary
17:08
62
Demo: efficient caching with ConcurrentDictionary.GetOrAdd
04:01
63
ConcurrentBag
06:18
64
Homework
00:47
65
Introduction
16:29
66
Pipelines
26:22
67
Demo: TcpEcho
18:29
68
Channels
19:56
69
Demo: Usage of the Channel<T> in ASP.NET Core
07:21
70
Homework
01:03
71
IValueTaskSource with Interlocked.CompareExchange
19:13
72
IValueTaskSource based on an array with token discriminator
11:01
73
ValueTask and pooling in .NET 5
11:26
74
ManualResetValueTaskSourceCore
11:33
75
False Sharing
09:56
76
Demo: Hosted services with IHostBuilder, IHostedService and ConcurrentQueue
13:19
77
F# async vs C# async
29:14
78
What's new in CancellationTokens for .NET 5 and beyond
13:11
79
Summary of the course
14:03
80
Marc Gravell, webinar nr 1
01:25:05
81
Daniel Marbach, webinar nr 2
01:01:11
82
Steve Cleary, webinar nr 3
01:05:19
83
Daniel Marbach, webinar nr 4
01:08:21
84
Marc Gravell, webinar nr 5
01:05:40
85
Steve Cleary, webinar nr 6
01:20:20
86
Daniel Marbach, webinar nr 7
55:41
Watch the other 85 lessons

One payment unlocks this course and every other premium course. No auto-renew.

See plans

Books

Read Book Async Expert

#TitleTypeOpen
1M01L01Overview —Unlock
2M01L02BenchmarkDotNet —Unlock
3M01L03Sharplab —Unlock
4M01L04ConcurrencyVisualizer —Unlock
5M01L06Homework —Unlock
6M02L01Introduction —Unlock
7M02L02Threads —Unlock
8M02L03ThreadsPools —Unlock
9M03L01TaskAPI —Unlock
10M03L02AsyncAwaitFoundations —Unlock
11M03L03AsyncEliding —Unlock
12M03L04ValueTask —Unlock
13M03L05TaskAPIandAsync —Unlock
14M03L06Homework —Unlock
15M04L01 —Unlock
16M04L02 —Unlock
17M04L03 —Unlock
18M04L04 —Unlock
19M04L05 —Unlock
20M04L06 —Unlock
21M04L07 —Unlock
22M05L01 —Unlock
23M05L02 —Unlock
24M05L03 —Unlock
25M05L04 —Unlock
26M06L01 —Unlock
27M06L02 —Unlock
28M06L03 —Unlock
29M06L04 —Unlock
30M06L05 —Unlock
31M07L01ExclusiveLocking —Unlock
32M07L02NonexclusiveLocking —Unlock
33M07L03Signalling —Unlock
34M07L04AsyncPrimitives —Unlock
35M07L05Homework —Unlock
36M08L01 —Unlock
37M08L02 —Unlock
38M08L03 —Unlock
39M08L04 —Unlock
40M09L04 —Unlock
41M09L03 —Unlock
42M09L02 —Unlock
43M09L01 —Unlock
44M10L01 —Unlock
45M10L02 —Unlock
46M10L03 —Unlock
47M10L04 —Unlock
48M10L05 —Unlock
49M10L07 —Unlock
50M10L08 —Unlock

What courses are similar to Async Expert?

More courses by Konrad Kokosa

  • .NET Memory Expert thumbnailUpdated 1y ago

    .NET Memory Expert

    «.NET Memory Expert» is a comprehensive 14-week online program focused on efficient memory management within the .NET environment.
    43h 15m5/5

Frequently asked questions

What are the prerequisites for enrolling in this course?
The course assumes that students have a basic understanding of .NET programming. Familiarity with C# and general programming concepts like threading and task-based programming will be beneficial. Prior experience with asynchronous programming is not required, as the course covers foundational concepts such as async-await and progresses to advanced techniques.
What kind of projects or exercises will I work on during the course?
The course includes various homework assignments designed to reinforce the material covered in lessons. These assignments include practical tasks such as implementing async-await patterns, working with concurrent collections like ConcurrentStack and ConcurrentQueue, and using advanced techniques such as task throttling with Task and SemaphoreSlim.
Who is the target audience for this course?
The course is aimed at software developers and engineers who want to deepen their understanding of asynchronous programming in the .NET environment. It is suitable for those looking to enhance their skills in concurrency and parallelism, as well as those interested in the practical applications of asynchronous techniques in real-world projects.
How does this course compare in depth and scope to similar courses?
This course offers a comprehensive exploration of asynchronous programming in .NET, covering both foundational concepts and advanced topics. Unlike introductory courses, it delves into complex subjects such as execution contexts, concurrent collections, and asynchronous primitives. It also includes exclusive materials from recognized experts, providing insights that may not be available in other courses.
What specific tools or platforms will be used in the course?
The course utilizes a variety of tools and platforms, including BenchmarkDotNet for performance measurement, sharplab.io for code experimentation, and ConcurrencyVisualizer for analyzing concurrent execution. Students will also engage with technologies like gRPC, Kestrel ASP.NET, and Aeron.NET through practical demonstrations.
What topics are not covered in this course?
While the course provides a detailed exploration of asynchronous programming in .NET, it does not cover topics outside of this scope, such as frontend development or other programming languages. It focuses specifically on .NET technologies and asynchronous patterns without delving into unrelated programming paradigms.
How much time should I expect to commit to this course?
The course consists of 86 lessons, with each lesson designed to provide a thorough understanding of asynchronous programming in .NET. Given the depth of content, students should expect to allocate sufficient time for lectures, homework assignments, and practical exercises to fully grasp the material and apply it effectively.