It was born after years of dealing with all sorts of different types of caches: memory caching, distributed caching, http caching, CDNs, browser cache, offline cache, you name it. So I've tried to put together these experiences and came up with FusionCache.

It uses a memory cache (any impl of the standard IMemoryCache interface) as the primary backing store and optionally a distributed, 2nd level cache (any impl of the standard IDistributedCache interface) as a secondary backing store for better resilience and higher performance, for example in a multi-node scenario or to avoid the typical effects of a cold start (initial empty cache, maybe after a restart).

Optionally, it can also use a backplane: in a multi-node scenario this will send notifications to the other nodes to keep all the memory caches involved perfectly synchronized, without any additional work.

FusionCache also includes some advanced features like cache stampede prevention, a fail-safe mechanism, fine grained soft/hard timeouts with background factory completion, customizable extensive logging and more (see below).

If you want to get yourself comfortable with the overall concepts there's 🦄 A Gentle Introduction available.

If you want to see what you can achieve from start to finish with FusionCache, there's a 👩‍🏫 Step By Step guide.

If instead you want to start using it immediately there's a ⭐ Quick Start for you.

On August 2021, FusionCache received the Google Open Source Peer Bonus Award. Here is the official blogpost.

These are the key features of FusionCache:

• 🚀 Cache Stampede prevention: using the optimized GetOrSet[Async] method prevents multiple concurrent factory calls per key, with a guarantee that only 1 will be executed at the same time for the same key. This avoids overloading the data source when no data is in the cache or when a cache entry expires
• 🔀 2nd level (optional): FusionCache can transparently handle an optional 2nd level cache: anything that implements the standard IDistributedCache interface is supported like Redis, MongoDB, CosmosDB, SqlServer and others, including a local disk-cache, too
• 📢 Backplane: when using a distributed cache as a 2nd layer in a multi-node scenario, you can also enable a backplane to immediately notify the other nodes about changes in the cache, to keep everything synchronized without having to do anything
• 💣 Fail-Safe: enabling the fail-safe mechanism prevents throwing an exception when a factory or a distributed cache call would fail, by reusing an expired entry as a temporary fallback, all transparently and with no additional code required
• ⏱ Soft/Hard timeouts: advanced timeouts management prevents waiting for too long when calling a factory or the distributed cache, to avoid hanging your application. It is possible to specify both soft and hard timeouts, and thanks to automatic background completion no data will be wasted
• 🧙‍♂️ Adaptive Caching: there are times when you don't know upfront what the cache duration for a piece of data should be, maybe because it depends on the object being cached itself. Adaptive caching solves this elegantly
• ⚡ High performance: FusionCache is optimized to minimize CPU usage and memory allocations to get better performance and lower the cost of your infrastructure all while obtaining a more stable, error resilient application
• 💫 Natively sync/async: full native support for both the synchronous and asynchronous programming model, with sync/async methods working together harmoniously
• 📞 Events: there's a comprehensive set of events to subscribe to regarding core events inside of a FusionCache instance, both at a high level and at lower levels (memory/distributed layers)
• 🧩 Plugins: thanks to a plugin subsystem it is possible to extend FusionCache with additional behaviour, like adding support for metrics, statistics, etc
• 📜 Logging: comprehensive, structured, detailed and customizable logging via the standard ILogger<T> interface (you can use Serilog, NLog, etc)
• 🔃 Dependency Injection: how to work with FusionCache + DI in .NET

Main packages:

Package Name	Version	Downloads
ZiggyCreatures.FusionCache The core package
ZiggyCreatures.FusionCache.Chaos A package with additional chaos-related utilities and implementations

Serializers:

Package Name	Version	Downloads
ZiggyCreatures.FusionCache.Serialization.NewtonsoftJson A serializer, based on Newtonsoft Json.NET
ZiggyCreatures.FusionCache.Serialization.SystemTextJson A serializer, based on the new System.Text.Json
ZiggyCreatures.FusionCache.Serialization.NeueccMessagePack A MessagePack serializer, based on the most used MessagePack serializer on .NET
ZiggyCreatures.FusionCache.Serialization.ProtoBufNet A Protobuf serializer, based on one of the most used protobuf-net serializer on .NET
ZiggyCreatures.FusionCache.Serialization.CysharpMemoryPack A serializer based on the uber fast new serializer by Neuecc, MemoryPack

Backplanes:

Package Name	Version	Downloads
ZiggyCreatures.FusionCache.Backplane.Memory An in-memory backplane (mainly for testing)
ZiggyCreatures.FusionCache.Backplane.StackExchangeRedis A Redis backplane, based on StackExchange.Redis

Third-party packages:

Package Name	Version	Downloads
JoeShook.ZiggyCreatures.FusionCache.Metrics.Core
JoeShook.ZiggyCreatures.FusionCache.Metrics.EventCounters
JoeShook.ZiggyCreatures.FusionCache.Metrics.AppMetrics

FusionCache can be installed via the nuget UI (search for the ZiggyCreatures.FusionCache package) or via the nuget package manager console:

PM> Install-Package ZiggyCreatures.FusionCache

As an example, imagine having a method that retrieves a product from your database:

Product GetProductFromDb(int id) {
	// YOUR DATABASE CALL HERE
}

💡 This is using the sync programming model, but it would be equally valid with the newer async one for even better performance.

To start using FusionCache the first thing is create a cache instance:

var cache = new FusionCache(new FusionCacheOptions());

If instead you are using DI (Dependency Injection) use this:

services.AddFusionCache();

We can also specify some global options, like a default FusionCacheEntryOptions object to serve as a default for each call we'll make, with a duration of 2 minutes and a Low priority:

var cache = new FusionCache(new FusionCacheOptions() {
	DefaultEntryOptions = new FusionCacheEntryOptions {
		Duration = TimeSpan.FromMinutes(2),
		Priority = CacheItemPriority.Low
	}
});

Or, using DI, like this:

services.AddFusionCache(options => {
	options.DefaultEntryOptions = new FusionCacheEntryOptions {
		Duration = TimeSpan.FromMinutes(2),
		Priority = CacheItemPriority.Low
	};
});

Now, to get the product from the cache and, if not there, get it from the database in an optimized way and cache it for 30 sec simply do this:

var id = 42;

cache.GetOrSet<Product>(
	$"product:{id}",
	_ => GetProductFromDb(id),
	TimeSpan.FromSeconds(30)
);

That's it 🎉

cache.GetOrSet<Product>(
	$"product:{id}",
	_ => GetProductFromDb(id),
	// THIS IS WHERE THE MAGIC HAPPENS
	options => options
		.SetDuration(TimeSpan.FromSeconds(30))
		.SetPriority(CacheItemPriority.High)
		.SetFailSafe(true, TimeSpan.FromHours(2))
		.SetFactoryTimeouts(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(2))
);

var cache = new FusionCache(new FusionCacheOptions() {
	DefaultEntryOptions = new FusionCacheEntryOptions()
		.SetDuration(TimeSpan.FromMinutes(2))
		.SetPriority(CacheItemPriority.High)
		.SetFailSafe(true, TimeSpan.FromHours(2))
		.SetFactoryTimeouts(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(2))
});

var id = 42;

cache.GetOrSet<Product>(
	$"product:{id}",
	_ => GetProductFromDb(id),
	options => options.SetDuration(TimeSpan.FromSeconds(30))
);

The documentation is available in the 📂 docs folder, with:

• 🦄 A Gentle Introduction: what you need to know first
• 🔀 Cache Levels: a bried description of the 2 available caching levels and how to setup them
• 📢 Backplane: how to get an always synchronized cache, even in a multi-node scenario
• 🚀 Cache Stampede prevention: no more overloads during a cold start or after an expiration
• 💣 Fail-Safe: an explanation of how the fail-safe mechanism works
• ⏱ Timeouts: the various types of timeouts at your disposal (calling a factory, using the distributed cache, etc)
• 🧙‍♂️ Adaptive Caching: how to adapt cache duration (and more) based on the object being cached itself
• 🎚 Options: everything about the available options, both cache-wide and per-call
• 🕹 Core Methods: what you need to know about the core methods available
• 📞 Events: the events hub and how to use it
• 🧩 Plugins: how to create and use plugins
• 📜 Logging: logging configuration and usage
• 🔃 Dependency Injection: how to work with FusionCache + DI in .NET

If you are in for a ride you can read a complete step by step example of why a cache is useful, why FusionCache could be even more so, how to apply most of the options available and what results you can expect to obtain.

There are various alternatives out there with different features, different performance characteristics (cpu/memory) and in general a different set of pros/cons.

A feature comparison between existing .NET caching solutions may help you choose which one to use.

FusionCache targets .NET Standard 2.0 so any compatible .NET implementation is fine: this means .NET Framework (the old one), .NET Core 2+ and .NET 5/6+ (the new ones), Mono 5.4+ and more (see here for a complete rundown).

NOTE: if you are running on .NET Framework 4.6.1 and want to use .NET Standard packages Microsoft suggests to upgrade to .NET Framework 4.7.2 or higher (see the .NET Standard Documentation) to avoid some known dependency issues.

The logo is an original creation and is a sloth because, you know, speed.

Nothing to do here.

After years of using a lot of open source stuff for free, this is just me trying to give something back to the community.

If you find FusionCache useful please just ✉️ drop me a line, I would be interested in knowing about your usage.

And if you really want to talk about money, please consider making ❤ a donation to a good cause of your choosing, and maybe let me know about that.

Yes!

Even though the current version is 0.X for an excess of caution, FusionCache is already used in production on multiple real world projects happily handling millions of requests per day, or at least these are the projects I'm aware of.

Considering that the FusionCache packages have been downloaded more than half a million times (thanks everybody!) it may very well be used even more.

And again, if you are using it please ✉ drop me a line, I'd like to know!