CacheManager is an open source caching abstraction layer for .NET written in C#. It supports various cache providers and implements many advanced features.
The main goal of the CacheManager package is to make developer's life easier to handle even very complex caching scenarios.
With CacheManager it is possible to implement multiple layers of caching, e.g. in-process caching in front of a distributed cache, in just a few lines of code.
CacheManager is not just an interface to unify the programming model for various cache providers, which will make it very easy to change the caching strategy later on in a project. It also offers additional features, like cache synchronization, concurrent updates, serialization, events, performance counters...
The developer can opt-in to those features only if needed.
CacheManager Nuget Packages
Supported framework targets changed since CacheManager 2.0. In case you have to target .NET 40 for example, you can still use CacheManager 1.x!
Beta versions of the CacheManager packages are getting pushed to https://www.myget.org/gallery/cachemanager on each build.
Add the following feed, if you want to play with the not yet released bits:
To find which check-in created which build, use this build history.
Documentation can be found on cachemanager.michaco.net:
Generated API documentation is also available.
CacheManager related blog posts can be found on my website
See benchmarks results on GitHub.
List of Features
- One common interface for handling different caching technologies:
- Configurable by
- Code with many different paths and a fluent configuration builder
- See configuration docs
- Support for different cache providers
Serialization can now be configured.
Serialization is only needed in distributed caches. If no additional serialization package is installed and configured, Binary serialization will be used (if available)
The following are the currently available serialization options:
- Binary (build in if the full CLR is being used)
Json based on the popular Newtonsoft.Json library
Json with Gzip compression
Bond based on Microsoft.Bond supporting all three available variants
DataContract based on System.Runtime.Serialization library supporting binary, Json & Json with Gzip compression
Protocol Buffer Google's protobuf. The package uses Mark's protobuf-net implementation.
Update values with lock or transaction for distributed caches.
The interfaced provides a simple update method which internally ensures you work with the latest version.
And CacheManager handles version conflicts for you.
Logging CacheManager comes with an extensible logging API.
- All standard cache operations are logged
- Based on log levels more or less information will be logged (try Trace and Debug)
- Current concrete implementation is based on the ASP.NET Core logging. Other implementation of CacheManager's ILoggerFactory might follow.
Strongly typed cache interface.
By having multiple cache handles managed by CacheManager, you can easily implement layered caches. For example, an in process cache in front of your distributed cache, to make read access faster.
CacheManager will synchronize those layers for you.
Add operations will always be executed on all cache handles registered on the manager.
Get, there are different configuration options defined by
CacheUpdateMode, if the item was available in one cache handle:
- None: No update across the cache handles on Get
- Up: Updates the handles "above"
- All: Updates/Adds the item to all handles
Expiration: It is possible to configure the expiration per cache handle within the manager or per cache item.
The following are the supported expiration modes:
- Sliding expiration: On cache hit, the cache item expiration timeout will be extended by the configured amount.
- Absolute expiration: The cache item will expire after the configured timeout.
- Since 1.0.0, evictions triggered by the cache vendor can trigger events and updates
Cache Regions: Even if some cache systems do not support or implement cache regions, the CacheManager implements the mechanism.
This can be used to for example group elements and remove all of them at once.
Statistics: Counters for all kind of cache actions.
Performance Counters: To be able to inspect certain numbers with
perfmon, CacheManager supports performance counters per instance of the manager and per cache handle.
Event System: CacheManager triggers events for common cache actions:
OnGet, OnAdd, OnPut, OnRemove, OnClear, OnClearRegion
- Events also get triggered by the backplane (if enabled) when multiple instances are sharing the same cache.
OnRemoveByHandle events triggered by actual expiration or memory pressure eviction by the cache vendor
- Events also get triggered through the backplane and via Redis keyspace events (if configured)
System.Web.OutputCache implementation to use CacheManager as OutputCache provider which makes the OutputCache extremely flexible, for example by using a distributed cache like Redis across many web servers.
Cache clients synchronization
- Implemented with the Redis pub/sub feature
- Supports .Net 4.5, and can be used in cross platform projects with the new .NET Core runtime