Skip to main content
CF

Async Expert

33h 11m 40s
English
Paid

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

Course facts

Lessons
86
Duration
33 hours 11 minutes
Level
All levels
Language
English
Updated
Instructor
Konrad Kokosa, Szymon Kulec, Łukasz Pyrzyk
Price
Premium

Master asynchronous programming in .NET with the Async Expert course. You will experience a deep dive from the basics to advanced techniques, such as async-await, working with concurrent collections, and managing parallelism.

The course includes homework assignments to consolidate knowledge as well as exclusive materials from recognized experts: Marc Gravell, Daniel Marbach, and Stephen Cleary.

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)

You can watch up to 10 minutes for free. Subscribe to unlock all 86 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
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
Unlock unlimited learning

Get instant access to all 85 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Books

Read Book Async Expert

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

What courses are similar to Async Expert?

  • .NET Memory Expert thumbnailUpdated 1y ago

    .NET Memory Expert

    By: Konrad Kokosa
    «.NET Memory Expert» is a comprehensive 14-week online program focused on efficient memory management within the .NET environment.
    43h 15m
  • Blazor WebAssembly thumbnailUpdated 1y ago

    Blazor WebAssembly

    By: Code Maze
    Blazor opens doors for .NET developers by offering the ability to create modern single-page applications (SPAs) using their favorite language, C#.
    8h 31m
  • ASP.NET Core Full Stack thumbnailUpdated 2y ago

    ASP.NET Core Full Stack

    By: Julio Casal
    This beginner-level course, led by Julio Casal, a seasoned software engineer and founder of Netbeckerservices.com, is designed to teach learners how to build a
    5h 26m

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.