Skip to main content
CourseFlix

.NET Memory Expert

43h 15m 52s
English
Paid

«.NET Memory Expert» is a comprehensive 14-week online program focused on efficient memory management within the .NET environment. This curriculum ranges from foundational concepts such as value and reference types to advanced subjects like Span<T> and Data-Oriented Design with native memory.

Importance of Memory Management in .NET

Even with automated memory management in .NET, a deep understanding of optimization techniques is crucial. Proper memory management is vital to prevent issues like memory leaks and excessive CPU usage, especially in large-scale applications.

Course Content Overview

  • Value and Reference Types: Understand the differences and their impact on performance.
  • Advanced Memory Concepts: Dive into Span<T> and explore native memory handling techniques.
  • Data-Oriented Design: Learn how to efficiently work with native memory structures to enhance application performance.

Practical Learning and Tools

The course includes hands-on exercises and practical assignments at the end of each module to reinforce learning. Participants will gain proficiency in using tools like PerfView for in-depth memory analysis and practice writing efficient C# code tailored for performance.

PerfView for Memory Analysis

Discover how to use PerfView to analyze and understand memory usage patterns in .NET applications, enabling you to effectively identify and resolve memory issues.

Writing Efficient C# Code

Learn best practices in C# programming that focus on memory efficiency and performance optimization. This course will guide you in writing cleaner, more efficient code.

Additional

https://github.com/dotnetos/memoryexpert-course

About the Author: 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.

Watch Online 65 lessons

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Introduction
All Course Lessons (65)
#Lesson TitleDurationAccess
1
Introduction Demo
28:25
2
.NET runtime - IL, JIT, assembler
02:54:18
3
Homework
00:52
4
Value vs reference type - layout, passing by value and reference
45:19
5
Stack vs heap
01:08:33
6
null/NullReferenceException
20:30
7
Array/list of classes/structs
15:25
8
Homework
00:37
9
Automatic memory management
01:07:43
10
Pauses/throughput/latency/aggressiveness
53:05
11
Your performance goal? Don't guess, measure
26:52
12
Homework
01:24
13
GC in .NET
31:40
14
GC modes, latency modes and other settings
01:56:25
15
Homework
01:05
16
Intro
06:13
17
Events
20:29
18
Event Tracing for Windows (ETW)
01:12:48
19
Linux Trace Toolkit Next Generation (LTTng)
25:50
20
EventPipes & CLI Diagnostic Tools
44:45
21
Homework
00:16
22
Counters
49:11
23
Dumps
01:32:49
24
Profilers & Application Performance Monitoring
19:40
25
Cloud & containers
57:41
26
Homework
00:15
27
Generations and other heaps
02:00:23
28
Roots
01:58:16
29
Homework
00:16
30
Operating system cooperation
01:03:21
31
The GC partitioning internals
01:17:47
32
The GC phases internals
01:11:07
33
Homework
00:27
34
Memory leak - because of no GCs
31:30
35
Memory leak - because of fragmentation
31:20
36
Memory leak - because of roots
58:59
37
Mid-life crisis and Nepotism
30:34
38
Homework
00:11
39
Andrey Akinshin
01:23:13
40
Christophe Nasarre
01:10:55
41
Konrad Kokosa - live Q&A
01:06:37
42
Measuring and self-measuring
01:05:09
43
Reducing allocations - hidden allocations
42:10
44
Reducing allocations - pooling
26:19
45
Reducing allocations - structs
52:45
46
Reducing allocations - strings
01:10:17
47
Homework
00:30
48
Finalization
53:46
49
Disposable objects
29:44
50
IoC containers
12:35
51
Weak references
23:37
52
Homework
00:12
53
Managed pointers
59:20
54
Span<T> and Memory<T>
01:41:49
55
Unsafe class
20:48
56
Pipelines
17:03
57
Homework
00:21
58
Hardware - memory, cache, CPU
35:29
59
Object layout vs cache
26:01
60
Access patterns
40:49
61
Homework
00:13
62
Pinning
29:01
63
Off the heap
09:19
64
Function pointers
11:20
65
Homework
00:09
Unlock unlimited learning

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

Learn more about subscription

Books

Read Book .NET Memory Expert

#TitleTypeOpen
1M01L01Introduction
2M01L02Runtime
3M01L03Homework
4M01L03HomeworkSolutions
5M02L01ValueVsReferenceType
6M02L02StackVsHeap
7M02L03null
8M02L04ArrayVsList
9M02L05Homework
10M03L01AutomaticMemory
11M03L02PausesThroughpu
12M03L03PerformanceGoal
13M03L04Homework
14M04L01GCinNET
15M04L02GCModes
16M04L03Homework
17M05L01ToolsIntro
18M05L02ToolsEvents
19M05L03ToolsETW
20M05L04ToolsLTTng
21M05L05ToolsEventPipes
22M05L06Homework
23M05L06HomeworkSolutions
24M06L01ToolsCounters
25M06L02ToolsDumps
26M06L03ToolsProfilersAPMs
27M06L04ToolsCloudContainers
28M06L05Homework
29M06L05HomeworkSolutions
30M07L01GenerationsAndHeaps
31M07L02Roots
32M07L03Homework
33M07L03HomeworkSolutions
34M08L01OperatingSystem
35M08L02Paritioning
36M08L03Phases
37M08L04Homework
38M08L04HomeworkSolutions
39M09L01MemoryLeakNoGCs
40sM09L02MemoryLeakFragmentation
41M09L03MemoryLeakRoots
42M09L04MidLifeCrisisAndNepotism
43M09L05Homework
44M09L06
45M09L07Dotnetos_NETCoreTroubleshootingSlides
46M10L01Allocations
47M10L02ReducingHidden
48M10L03ReducingPooling
49M10L04ReducingStructs
50M10L05ReducingStrings
51M10L06Homework
52M11L01Finalization
53M11L02DisposableObjects
54M11L03IoCContainers
55M11L04WeakReferences
56M11L05HomeworkInstructions
57M12L01ManagedPointers
58M12L02SpanMemory
59M12L03Unsafe
60M12L04Pipellines
61M12L05Homework
62M13L01Hardware
63M13L02ObjectLayoutVsCache
64M13L03AccessPatterns
65M13L04HomeworkInstructions
66M14L01Pinning
67M14L02OffTheHeap
68M14L03FunctionPointers
69M14L04HomeworkInstructions

Course content

65 lessons · 43h 15m 52s
Show all 65 lessons
  1. 1 Introduction 28:25
  2. 2 .NET runtime - IL, JIT, assembler 02:54:18
  3. 3 Homework 00:52
  4. 4 Value vs reference type - layout, passing by value and reference 45:19
  5. 5 Stack vs heap 01:08:33
  6. 6 null/NullReferenceException 20:30
  7. 7 Array/list of classes/structs 15:25
  8. 8 Homework 00:37
  9. 9 Automatic memory management 01:07:43
  10. 10 Pauses/throughput/latency/aggressiveness 53:05
  11. 11 Your performance goal? Don't guess, measure 26:52
  12. 12 Homework 01:24
  13. 13 GC in .NET 31:40
  14. 14 GC modes, latency modes and other settings 01:56:25
  15. 15 Homework 01:05
  16. 16 Intro 06:13
  17. 17 Events 20:29
  18. 18 Event Tracing for Windows (ETW) 01:12:48
  19. 19 Linux Trace Toolkit Next Generation (LTTng) 25:50
  20. 20 EventPipes & CLI Diagnostic Tools 44:45
  21. 21 Homework 00:16
  22. 22 Counters 49:11
  23. 23 Dumps 01:32:49
  24. 24 Profilers & Application Performance Monitoring 19:40
  25. 25 Cloud & containers 57:41
  26. 26 Homework 00:15
  27. 27 Generations and other heaps 02:00:23
  28. 28 Roots 01:58:16
  29. 29 Homework 00:16
  30. 30 Operating system cooperation 01:03:21
  31. 31 The GC partitioning internals 01:17:47
  32. 32 The GC phases internals 01:11:07
  33. 33 Homework 00:27
  34. 34 Memory leak - because of no GCs 31:30
  35. 35 Memory leak - because of fragmentation 31:20
  36. 36 Memory leak - because of roots 58:59
  37. 37 Mid-life crisis and Nepotism 30:34
  38. 38 Homework 00:11
  39. 39 Andrey Akinshin 01:23:13
  40. 40 Christophe Nasarre 01:10:55
  41. 41 Konrad Kokosa - live Q&A 01:06:37
  42. 42 Measuring and self-measuring 01:05:09
  43. 43 Reducing allocations - hidden allocations 42:10
  44. 44 Reducing allocations - pooling 26:19
  45. 45 Reducing allocations - structs 52:45
  46. 46 Reducing allocations - strings 01:10:17
  47. 47 Homework 00:30
  48. 48 Finalization 53:46
  49. 49 Disposable objects 29:44
  50. 50 IoC containers 12:35
  51. 51 Weak references 23:37
  52. 52 Homework 00:12
  53. 53 Managed pointers 59:20
  54. 54 Span<T> and Memory<T> 01:41:49
  55. 55 Unsafe class 20:48
  56. 56 Pipelines 17:03
  57. 57 Homework 00:21
  58. 58 Hardware - memory, cache, CPU 35:29
  59. 59 Object layout vs cache 26:01
  60. 60 Access patterns 40:49
  61. 61 Homework 00:13
  62. 62 Pinning 29:01
  63. 63 Off the heap 09:19
  64. 64 Function pointers 11:20
  65. 65 Homework 00:09

Related courses

Frequently asked questions

What is .NET Memory Expert about?
«.NET Memory Expert» is a comprehensive 14-week online program focused on efficient memory management within the .NET environment. This curriculum ranges from foundational concepts such as value and reference types to advanced subjects…
Who teaches .NET Memory Expert?
.NET Memory Expert is taught by Konrad Kokosa. You can find more courses by this instructor on the corresponding source page.
How long is .NET Memory Expert?
.NET Memory Expert contains 65 lessons with a total runtime of 43 hours 15 minutes. All lessons are available to watch online at your own pace.
Is .NET Memory Expert free to watch?
.NET Memory Expert is part of CourseFlix's premium catalog. A CourseFlix subscription unlocks the full video player; the course description, table of contents, and preview information are available to everyone.
Where can I watch .NET Memory Expert online?
.NET Memory Expert is available to watch online on CourseFlix at https://courseflix.net/course/net-memory-expert. The page hosts every lesson with the integrated video player; no download is required.