Advanced thread-safe generic wrapper for System.Runtime.Caching with comprehensive features including cache groups, dependency management, automatic population, and persistent disk storage.
Key Features:
• Cache groups for organized data management
• Dependency relationships between cache groups
• Automatic cache population with custom methods
• Persistent cache storage that survives application restarts
• Retrieve all items from a group with GetAllByGroup()
• Comprehensive metadata and monitoring with GetAllCacheMetadata()
• Detailed statistics and disk usage analysis
• Multiple expiration strategies (sliding/absolute)
• Auto-refresh with configurable intervals
• Thread-safe operations with minimal lock contention
• JSON-based serialization for persistent storage
Perfect for high-performance applications requiring sophisticated caching patterns, data persistence, and comprehensive monitoring capabilities.
A thread-safe, generic wrapper for System.Runtime.Caching that simplifies cache access and supports powerful caching patterns.
Overview
CacheUtility provides an easy-to-use abstraction over the standard .NET memory cache with additional features:
Automatic cache population
Various expiration strategies
Thread-safe operations
Support for cache groups
Dependency relationships between cache groups
Basic Usage
Note: All examples assume you have added the using statement:
using CacheUtility;
Retrieving or Creating Cached Items
The most common pattern is to request an item from the cache, providing a function to generate the item if it doesn't exist:
// Basic usage with default 30-minute sliding expiration
var result = Cache.Get("MyKey", "MyGroupName", () =>
{
return MyLongRunningTask();
});
// With custom sliding expiration
var result = Cache.Get("MyKey", "MyGroupName", TimeSpan.FromHours(1), () =>
{
return MyLongRunningTask();
});
// With absolute expiration
var result = Cache.Get("MyKey", "MyGroupName", DateTime.Now.AddDays(1), () =>
{
return MyLongRunningTask();
});
// With full customization
var result = Cache.Get("MyKey", "MyGroupName",
DateTime.Now.AddDays(1), // Absolute expiration
TimeSpan.FromMinutes(10), // Sliding expiration
CacheItemPriority.Default, // Priority
() => MyLongRunningTask());
Async Operations
For async operations, you can use the utility with async/await:
var result = await Cache.Get("MyKey", "MyGroupName", async () =>
{
return await MyLongRunningTaskAsync();
});
Cache Management
Removing Individual Items
Remove a specific item from the cache:
Cache.Remove("MyKey", "MyGroupName");
Removing Multiple Items
Remove multiple items that contain specific strings:
Cache.Remove(new List<string> { "UserProfile", "123" }, "UserData");
// This will remove any cache key containing both "UserProfile" and "123"
Group Operations
Remove an entire group of cached items:
Cache.RemoveGroup("MyGroupName");
Remove multiple groups:
Cache.RemoveGroup("GroupA", "GroupB", "GroupC");
Retrieving All Items from a Group
Get all cached items that belong to a specific group:
var allItems = Cache.GetAllByGroup("MyGroupName");
// Iterate through all items in the group
foreach (var kvp in allItems)
{
Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
}
// Access specific items if you know the key
if (allItems.ContainsKey("MySpecificKey"))
{
var specificItem = allItems["MySpecificKey"];
}
Set up dependencies between cache groups so that when one group is cleared, its dependent groups are also cleared:
// Set up dependencies
Cache.SetDependencies("ParentGroup", "ChildGroup1", "ChildGroup2");
// Now when ParentGroup is removed, ChildGroup1 and ChildGroup2 will also be removed
Cache.RemoveGroup("ParentGroup");
Practical Examples
Caching User Data
// Cache user data with a sliding expiration
var userData = Cache.Get($"User_{userId}", "UserProfiles", TimeSpan.FromMinutes(30), () =>
{
return database.GetUserById(userId);
});
Caching Application Settings
// Cache application settings with absolute expiration
var settings = Cache.Get("GlobalSettings", "AppConfig", DateTime.Now.AddHours(12), () =>
{
return configurationService.LoadSettings();
});
Working with Multiple Cached Items
// Cache some user data
Cache.Get("User1", "UserData", () => GetUserInfo(1));
Cache.Get("User2", "UserData", () => GetUserInfo(2));
Cache.Get("User3", "UserData", () => GetUserInfo(3));
// Get all cached items from the group
var allUsers = Cache.GetAllByGroup("UserData");
Console.WriteLine($"Found {allUsers.Count} cached users");
// Process each cached item
foreach (var user in allUsers)
{
Console.WriteLine($"User Key: {user.Key}, Data: {user.Value}");
}
Cascading Cache Invalidation
// Set up dependencies
Cache.SetDependencies("UserData", "UserProfiles", "UserPreferences", "UserActivity");
Cache.SetDependencies("UserProfiles", "ProfilePhotos");
// Now when UserData is cleared, all dependent caches are also cleared
Cache.RemoveGroup("UserData");
// This will clear UserData, UserProfiles, ProfilePhotos, UserPreferences, and UserActivity
Best Practices
Group Related Items: Use meaningful group names to organize related cache items.
Consider Expiration Strategies: Choose between sliding expiration (reset on access) and absolute expiration (fixed time) based on your use case.
Set Dependencies: Use cache dependencies to maintain consistency between related data.
Use Short Keys: Keep your cache keys concise but descriptive.
Performance Considerations
The CacheUtility uses locks to ensure thread safety, but is designed to minimize lock contention.
Populate methods are only called once per cache miss, even under high concurrency.
Consider memory usage when caching large objects or collections.
When to Use Cache Groups vs. Key Prefixes
Cache Groups: Use when you need to invalidate multiple related items at once.
Key Prefixes: Use within your keys when you want to organize items but may need more granular control.
Memory Management
The CacheUtility is built on top of .NET's MemoryCache, which has built-in memory pressure detection. However, be mindful of:
Setting appropriate cache priorities
Using reasonable expiration times
Caching only necessary data
Thread Safety
All operations in CacheUtility are thread-safe. The implementation uses ReaderWriterLockSlim for efficient concurrent access and CacheLock for synchronizing modifications to the cache.