Let's make the hardest thing in programming easy for .NET software engineers.
Caching is fundamental in building fast, scalable and resilient applications. It's also famously one of the two hardest things in software engineering, the other one being naming things. It's everywhere from apps to services, from hardware to software, from file systems to databases and at the very foundation of the internet and the web. In this course, Jody Donetti condensed over 20 years of real-world experience he gained while working on various cache types, including memory, distributed, hybrid, HTTP caching, offline caching, and CDNs. You'll explore the fundamentals of caching, both in general and on .NET, covering core concepts, mental models, techniques, best practices, common scenarios, recurring problems, and how to solve them with a focus on pragmatic solutions that can be immediately applied in the real world. The course will cover different caches, both from Microsoft and the amazing .NET open-source community, including FusionCache, which Jody created and is used even by Microsoft themselves. Ultimately, this knowledge will make your applications faster, more scalable, and robust - in short, better.
Curriculum
Welcome (04:00)
What will you learn in this course? (02:32)
Who is the course for and prerequisites (01:21)
What is caching? (02:36)
Is caching important? (05:53)
Cache all the things! (00:41)
When should we cache? When not? (03:06)
What should we cache? What not? (01:07)
How should we cache? How not? (01:14)
The "database" (00:58)
Memoization (01:37)
What is a cache? (01:03)
Cache Key (02:20)
Values & Entries (01:06)
Cache Internals (01:32)
Eviction & Friends (02:03)
Invalidation (01:59)
Expiration (02:51)
Eviction Policies (02:00)
Options (01:42)
Core Methods (05:42)
Factory (02:15)
Hit & Miss (01:07)
Refresh Cycle (01:11)
A cache is not a database (01:48)
Caching without a cache (04:54)
Intro (00:53)
The basics (04:17)
Remove (02:19)
Handling null (04:39)
Expiration (10:37)
Options (06:08)
Validation (03:35)
Concurrency (02:06)
Eviction (08:02)
Disposal (09:10)
Last touches (06:43)
The Prestige (05:54)
Low Level VS High Level (01:16)
Cache Types (00:31)
Memory Caches (01:52)
Distributed Caches (03:34)
Hybrid Caches (07:34)
Which Cache Type To Use? (02:39)
A Memory Cache Is Not A Memory Cache (01:48)
The caches we'll use (01:00)
MemoryCache (03:19)
FusionCache (15:33)
HybridCache (06:04)
HybridCache Limitations & Issues (07:27)
FusionCache as HybridCache (11:31)
Microsoft + OSS (03:21)
OSS alternatives (08:59)
Comparison (02:16)
Public Constructors (01:33)
Dependency Injection (04:42)
Builder (03:21)
Default Entry Options (08:42)
Sharing A Single Cache (02:59)
Multiple Named Caches (10:57)
Cache Key Prefix (04:01)
Cache Stampede (04:01)
GetOrSet, don't Get + Set (01:09)
Why nulls can be good (04:01)
Alternatives to nulls (02:19)
Describing Cache Entries (02:18)
Priority (00:57)
Manual Compaction (03:57)
Size & SizeLimit (02:08)
Automatic Compaction (09:50)
Clear (06:59)
Fallacies of Distributed Computing (03:17)
Resiliency (01:08)
Database Failures (01:37)
Fail-Safe (17:39)
Expire (02:46)
Write Data: Then What? (02:24)
Application Writes (10:56)
External Writes (06:39)
Strategies... not (03:03)
Database Slowdowns (01:48)
Eager Refresh (06:39)
Database Slowdowns - Part II (02:09)
Factory Timeouts (10:05)
Eager Refresh VS Factory Timeouts (08:20)
Background Factory Execution (10:08)
Microcaching (12:28)
Immutability (08:00)
Cache Bypass (03:48)
Adaptive Caching (09:07)
Fallacies Of Distributed Computing (again) (03:04)
Step By Step (17:57)
Conclusion (03:20)
Course Info
Level:
Getting Started Duration:
7h 3m Rating (New):
About the Author
Jody Donetti
Jody is a Principal Engineer doing coding, R&D and architecture for the past 30 years. He enjoys designing, developing and evolving software, and has worked on all sorts of things: websites, services, offline pipelines, PWAs, native mobile apps, digital publishing systems, video streaming platforms and CDNs, all happily handling millions of users all around the world. Dealt with most types of caches: memory, distributed, hybrid, HTTP caching and offline caching. Created FusionCache, an easy to use, fast and robust hybrid cache with advanced resiliency features. FusionCache is also the world's first production-ready implementation of Microsoft HybridCache. For his work on FusionCache he received both a Google OpenSource Award and a Microsoft MVP Award.
More courses by Jody Donetti© 2025 Dometrain. All rights reserved.