NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
NuGet, #1791 most downloaded on NuGet
FusionCache serializer based on Newtonsoft Json.NET
Latest stable
2.9.0
Last release 1 months ago
22 Sep 2026
Release timing varies
gaps range from 8 days to 5 months
Nearly every release is documented
notes for 46 of 47 stable releases
Nothing withdrawn
no release was ever pulled
6 years old
66 releases · first in 2020
Drag across the ruler to compare, or tap a release to open it.
FusionCache now has an extensibility mechanism thanks to a plugins subsystem: you can easily create your own plugin and subscribe to core events to do
FusionCache now has an extensibility mechanism thanks to a plugins subsystem: you can easily create your own plugin and subscribe to core events to do whatever you want.
There's an introductory guide and a complete sample available.
FusionCache now has a comprehensive set of events to subscribe to, so you can be notified of core events when they happen.
FusionCache now has a comprehensive set of events to subscribe to, so you can be notified of core events when they happen.
Example:
// SUBSCRIBE TO CACHE MISS EVENTS
cache.Events.Miss += (s, e) => {
// REACT TO THE EVENT HERE, WITH THE RELATED CACHE KEY AVAILABLE VIA e.Key
};
This is also a stepping stone towards the next step: plugins (#15).
And thanks to @JoeShook for the invaluable help!
Added some perf optimizations.
Your coding agent can read these notes before it upgrades. Set up the MCP server →
The only case of an actual breaking change is if you were doing something like this:
MaybeValue<T> (more)A new type has been introduced to model a value that may be there or not, just like the standard .NET nullables but for both reference and value types.
It supports implicit convesion to/from T and is used in a couple of places (see below).
TryGet[Async] (more)The TryGet[Async] return type is now MaybeValue<T> for better ease of use (more like the standard .NET nullables).
Example:
var maybeFoo = cache.TryGet<int>("foo");
if (maybeFoo.HasValue) {
// EXPLICIT ACCESS
var foo = maybeFoo.Value;
// OR IMPLICIT CONVERSION
int foo = maybeFoo;
}
GetOrSet[Async] (more)The GetOrSet[Async] methods now has an additional failSafeDefaultValue param to handle factory failures (with fail-safe enabled) in case there's no expired/stale value to use (eg: cold start, first use, etc).
Example:
// WITH FAIL-SAFE ENABLED
cache.GetOrSet<int>("foo", _ => GetFooFromDb(), 42);
There's also a new GetOrSet[Async] overload available that accepts a value directly instead of a factory: this covers the cases when you already have a default value to use so you don't have to allocate a useless lambda.
Example:
// BEFORE
cache.GetOrSet<int>("foo", _ => 42);
// FROM v0.1.3
cache.GetOrSet<int>("foo", 42);
The TryGet[Async] methods now returns a MaybeValue<T> instead of a TryGetResult<T>.
This new type also contains the Success prop present in the old TryGetResult<T> type, but marked as [Obsolete] to better ease the transition.
Also, the old TryGetResult<T> type is still there, in case you've used that somewhere, but the type as a whole has been marked as [Obsolete] to warn of the usage.
The only case of an actual breaking change is if you were doing something like this:
// USING IMPLICIT bool CONVERSION
if (cache.TryGet<int>("foo")) {
[...]
}
but it should have been rare, since the value would have been discarded. Anyway, in that case, you simply have to do this now:
if (cache.TryGet<int>("foo").HasValue) {
[...]
}
or, even better:
var maybeFoo = cache.TryGet<int>("foo");
if (maybeFoo.HasValue) {
// EXPLICIT ACCESS
var foo = maybeFoo.Value;
// OR IMPLICIT CONVERSION
int foo = maybeFoo;
}
Optimized cpu and memory usage so that common scenarios will consume less resources.
Fixed a bug about deserializing an entry's metadata with the System.Text.Json serializer (thanks @Paulskit!)
Fixed a bug about deserializing an entry's metadata with the System.Text.Json serializer (thanks @Paulskit!)
Better support for caching flows with _flexible_ types. Previously, doing this:
Better support for caching flows with flexible types. Previously, doing this:
var data = (object)42;
cache.Set("foo", data);
cache.GetOrDefault<int>("foo");
would not have resulted in getting back 42 .
Thanks to type inference the Set method call in the 2nd line in reality is a Set<object> and this, in addition to various internal details to support advanced features (fail-safe, etc), made it incompatible to transparently swich from one type to the other.
Now this scenario is fully supported 🎉
The first and last namespace change: the general namespace changed from ZiggyCreatures.FusionCaching to ZiggyCreatures.Caching.Fusion.
The fix should be very easy: update the packages, compile, see where it fails and change a couple of usings, that's it.
Sorry for this hassle 🙏 , it will be the last time.
Optimized cpu and memory usage so that common scenarios will consume less resources.
Almost all the main features currently planned are there, with tests, documentation and whatnot.
Initial release.
Almost all the main features currently planned are there, with tests, documentation and whatnot.
One column per quarter.