Jitbit.FastCache 1.3.0

FastCache

7x-10x faster alternative to MemoryCache. A high-performance, lighweight (8KB dll) and memory cache for .NET Core (.NET 6 and later)

👁 NuGet version
👁 .NET

TL;DR

Basically it's just a ConcurrentDictionary with expiration.

Benchmarks

Windows:

Linux (Ubuntu, Docker):

How is FastCache better

Compared to System.Runtime.Caching.MemoryCache and Microsoft.Extensions.Caching.MemoryCache FastCache is

• 7X faster reads (11X under Linux!)
• 10x faster writes
• Thread safe and atomic
• Generic (strongly typed keys and values) to avoid boxing/unboxing primitive types
• MemoryCache uses string keys only, so it allocates strings for keying
• MemoryCache comes with performance counters that can't be turned off
• MemoryCache uses heuristic and black magic to evict keys under memory pressure
• MemoryCache uses more memory, can crash during a key scan

Usage

Install via nuget

Install-Package Jitbit.FastCache

Then use

var cache = new FastCache<string, int>();

cache.AddOrUpdate(
	key: "answer",
	value: 42,
	ttl: TimeSpan.FromMinutes(1));

cache.TryGet("answer", out int value); //value is "42"

//factory pattern! calls the expensive factory only if not cached yet
cache.GetOrAdd(
	key: "answer",
	valueFactory: k => 42,
	ttl: TimeSpan.FromMilliseconds(100));

//handy overload to prevent captures/closures allocation
cache.GetOrAdd(
	key: "answer",
	valueFactory: (k, arg) => 42 + arg.Length,
	ttl: TimeSpan.FromMilliseconds(100),
	factoryArgument: "some state data");

Tradeoffs

FastCache uses Environment.TickCount to monitor items' TTL. Environment.TickCount is 104x times faster than using DateTime.Now and 26x times faster than DateTime.UtcNow.

The above is no longer valid, we have switched to .NET 6 targeting and now use TickCount64 which is free of this problem.

Another tradeoff: MemoryCache watches memory usage, and evicts items once it senses memory pressure. FastCache does not do any of that it is up to you to keep your caches reasonably sized. After all, it's just a dictionary.

API Reference

FastCache<TKey, TValue>

Implements IEnumerable<KeyValuePair<TKey, TValue>>, IDisposable.

Constructor

FastCache(int cleanupJobInterval = 10000, EvictionCallback itemEvicted = null)

Creates a new empty cache instance.

Methods

AddOrUpdate(TKey key, TValue value, TimeSpan ttl)

Adds an item to cache or updates it if it already exists. Updating resets the TTL (sliding expiration).

AddOrUpdate(TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory, TimeSpan ttl)

Factory overload. Uses addValueFactory when the key is new, updateValueFactory when it exists.

TryGet(TKey key, out TValue value) → bool

Attempts to get a value by key. Returns true if found and not expired.

TryAdd(TKey key, TValue value, TimeSpan ttl) → bool

Attempts to add a key/value item. Returns false if the key already exists (and is not expired).

GetOrAdd(TKey key, Func<TKey, TValue> valueFactory, TimeSpan ttl) → TValue

Returns existing value if cached, otherwise calls the factory to create, cache, and return it.

GetOrAdd(TKey key, TValue value, TimeSpan ttl) → TValue

Returns existing value if cached, otherwise adds the provided value and returns it.

GetOrAdd<TArg>(TKey key, Func<TKey, TArg, TValue> valueFactory, TimeSpan ttl, TArg factoryArgument) → TValue

Same as GetOrAdd but accepts a factoryArgument to avoid closure allocations.

Touch(TKey key, TimeSpan ttl)

Resets the TTL for an existing (non-expired) item — sliding expiration.

Remove(TKey key)

Removes the item with the specified key.

TryRemove(TKey key, out TValue value) → bool

Removes the item and returns the removed value. Returns false if not found or expired.

EvictExpired()

Manually triggers cleanup of expired items. Rarely needed since TryGet checks TTL anyway.

Properties

Clear()

Removes all items from the cache.

Delegate

delegate void EvictionCallback(TKey key, TValue value)

Callback invoked (on thread pool) when an item is evicted from the cache.