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.
Set up dependencies between cache groups so that when one group is cleared, its dependent groups are also cleared:
// Set up dependencies
CacheUtility.SetDependencies("ParentGroup", "ChildGroup1", "ChildGroup2");
// Now when ParentGroup is removed, ChildGroup1 and ChildGroup2 will also be removed
CacheUtility.RemoveGroup("ParentGroup");
// Cache user data with a sliding expiration
var userData = CacheUtility.Get($"User_{userId}", "UserProfiles", TimeSpan.FromMinutes(30), () =>
{
return database.GetUserById(userId);
});
Caching Application Settings
// Cache application settings with absolute expiration
var settings = CacheUtility.Get("GlobalSettings", "AppConfig", DateTime.Now.AddHours(12), () =>
{
return configurationService.LoadSettings();
});
Cascading Cache Invalidation
// Set up dependencies
CacheUtility.SetDependencies("UserData", "UserProfiles", "UserPreferences", "UserActivity");
CacheUtility.SetDependencies("UserProfiles", "ProfilePhotos");
// Now when UserData is cleared, all dependent caches are also cleared
CacheUtility.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.