🔄 .NET 缓存框架全面对比

3. 开源缓存框架

3.1 FusionCache（⭐ 推荐）

包: ZiggyCreatures.FusionCache

// 注册
builder.Services.AddFusionCache()
    .WithDefaultEntryOptions(new FusionCacheEntryOptions
    {
        Duration = TimeSpan.FromHours(1),
        
        // 防击穿：故障安全
        IsFailSafeEnabled = true,
        FailSafeMaxDuration = TimeSpan.FromDays(1),
        FailSafeThrottleDuration = TimeSpan.FromSeconds(30),
        
        // 防击穿：工厂超时
        FactorySoftTimeout = TimeSpan.FromMilliseconds(100),
        FactoryHardTimeout = TimeSpan.FromSeconds(2),
        
        // 防雪崩：随机抖动
        JitterMaxDuration = TimeSpan.FromMinutes(2),
        
        // 后台刷新
        AllowBackgroundDistributedCacheOperations = true,
        AllowBackgroundBackplaneOperations = true
    })
    // L2: Redis
    .WithDistributedCache(new RedisCache(new RedisCacheOptions
    {
        Configuration = "localhost:6379"
    }))
    // 序列化
    .WithSerializer(new FusionCacheSystemTextJsonSerializer())
    // 背板（多实例同步）
    .WithBackplane(new RedisBackplane(new RedisBackplaneOptions
    {
        Configuration = "localhost:6379"
    }));

// 使用
public class ProductService
{
    private readonly IFusionCache _cache;
    
    public async Task<Product?> GetProductAsync(int id)
    {
        return await _cache.GetOrSetAsync(
            $"product:{id}",
            async ct => await _repository.GetByIdAsync(id, ct),
            new FusionCacheEntryOptions
            {
                Duration = TimeSpan.FromHours(1),
                FailSafeMaxDuration = TimeSpan.FromDays(1)
            }
        );
    }
    
    // Adaptive Caching：根据数据动态调整缓存策略
    public async Task<Product?> GetProductAdaptiveAsync(int id)
    {
        return await _cache.GetOrSetAsync(
            $"product:{id}",
            async (ctx, ct) =>
            {
                var product = await _repository.GetByIdAsync(id, ct);
                
                // 根据数据特征动态调整缓存时间
                if (product?.IsHotSale == true)
                    ctx.Options.Duration = TimeSpan.FromMinutes(5);  // 热销品短缓存
                else
                    ctx.Options.Duration = TimeSpan.FromHours(2);    // 普通品长缓存
                
                return product;
            }
        );
    }
}

// 注册
builder.Services.AddLazyCache();

// 使用
public class ProductService
{
    private readonly IAppCache _cache;
    
    public async Task<Product?> GetProductAsync(int id)
    {
        return await _cache.GetOrAddAsync(
            $"product:{id}",
            async entry =>
            {
                entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1);
                return await _repository.GetByIdAsync(id);
            }
        );
    }
}

// 注册多级缓存
builder.Services.AddEasyCaching(options =>
{
    // L1: 内存
    options.UseInMemory("m1");
    
    // L2: Redis
    options.UseRedis(config =>
    {
        config.DBConfig.Endpoints.Add(new ServerEndPoint("localhost", 6379));
    }, "r1");
    
    // 混合缓存
    options.UseHybrid(config =>
    {
        config.TopicName = "cache-sync";
        config.LocalCacheProviderName = "m1";
        config.DistributedCacheProviderName = "r1";
    });
    
    // Redis 总线（多实例同步）
    options.WithRedisBus(config =>
    {
        config.Endpoints.Add(new ServerEndPoint("localhost", 6379));
    });
});

// 使用
public class ProductService
{
    private readonly IHybridCachingProvider _cache;
    
    public async Task<Product?> GetProductAsync(int id)
    {
        var result = await _cache.GetAsync<Product>($"product:{id}");
        
        if (result.HasValue)
            return result.Value;
        
        var product = await _repository.GetByIdAsync(id);
        if (product != null)
        {
            await _cache.SetAsync($"product:{id}", product, TimeSpan.FromHours(1));
        }
        
        return product;
    }
}

// 配置
var cache = CacheFactory.Build<Product>(settings =>
{
    settings
        .WithSystemRuntimeCacheHandle("memory")  // L1
        .And
        .WithRedisConfiguration("redis", config =>
        {
            config.WithEndpoint("localhost", 6379);
        })
        .WithRedisCacheHandle("redis");  // L2
});

// 使用
var product = cache.GetOrAdd("product:1", key => _repository.GetById(1));

// 更新
cache.Put("product:1", updatedProduct);

// 删除
cache.Remove("product:1");

你的需求是什么？
│
├── 仅需本地缓存？
│   ├── 需要极简 API？ → LazyCache
│   └── 标准官方方案？ → IMemoryCache
│
├── 需要分布式缓存？
│   ├── 仅分布式，无多级？ → IDistributedCache + Redis
│   └── 需要多级缓存？
│       ├── .NET 9+？ → HybridCache
│       └── .NET 8 及以下？ → FusionCache
│
├── 需要高可用/防击穿/故障安全？
│   └── FusionCache（最完善）
│
├── 需要多实例缓存同步？
│   ├── FusionCache + Backplane
│   └── EasyCaching + Redis Bus
│
└── 需要 AOP 注解式缓存？
    └── EasyCaching

<!-- 微软官方 -->
<PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="8.0.0" />
<PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="8.0.0" />
<PackageReference Include="Microsoft.Extensions.Caching.Hybrid" Version="9.0.0" /> <!-- .NET 9 -->

<!-- FusionCache -->
<PackageReference Include="ZiggyCreatures.FusionCache" Version="1.2.0" />
<PackageReference Include="ZiggyCreatures.FusionCache.Serialization.SystemTextJson" Version="1.2.0" />
<PackageReference Include="ZiggyCreatures.FusionCache.Backplane.StackExchangeRedis" Version="1.2.0" />

<!-- LazyCache -->
<PackageReference Include="LazyCache" Version="2.4.0" />
<PackageReference Include="LazyCache.AspNetCore" Version="2.4.0" />

<!-- EasyCaching -->
<PackageReference Include="EasyCaching.Core" Version="1.9.2" />
<PackageReference Include="EasyCaching.InMemory" Version="1.9.2" />
<PackageReference Include="EasyCaching.Redis" Version="1.9.2" />
<PackageReference Include="EasyCaching.HybridCache" Version="1.9.2" />

public static class CacheConfiguration
{
    public static IServiceCollection AddProductionCache(
        this IServiceCollection services,
        IConfiguration configuration)
    {
        var redisConnection = configuration.GetConnectionString("Redis");
        
        services.AddFusionCache()
            .WithDefaultEntryOptions(new FusionCacheEntryOptions
            {
                // 默认缓存时间
                Duration = TimeSpan.FromHours(1),
                
                // 故障安全：Redis 不可用时返回过期数据
                IsFailSafeEnabled = true,
                FailSafeMaxDuration = TimeSpan.FromDays(1),
                FailSafeThrottleDuration = TimeSpan.FromSeconds(30),
                
                // 防击穿：软超时后返回旧数据，后台继续加载
                FactorySoftTimeout = TimeSpan.FromMilliseconds(100),
                FactoryHardTimeout = TimeSpan.FromSeconds(2),
                
                // 防雪崩：随机抖动
                JitterMaxDuration = TimeSpan.FromMinutes(2),
                
                // 后台操作
                AllowBackgroundDistributedCacheOperations = true,
                AllowBackgroundBackplaneOperations = true
            })
            // L2 缓存
            .WithDistributedCache(
                new RedisCache(new RedisCacheOptions { Configuration = redisConnection }))
            // 序列化
            .WithSerializer(new FusionCacheSystemTextJsonSerializer())
            // 背板：多实例同步
            .WithBackplane(
                new RedisBackplane(new RedisBackplaneOptions { Configuration = redisConnection }))
            // OpenTelemetry
            .WithRegisteredLogger();
        
        return services;
    }
}

public static class CacheConfiguration
{
    public static IServiceCollection AddProductionHybridCache(
        this IServiceCollection services,
        IConfiguration configuration)
    {
        // L2: Redis
        services.AddStackExchangeRedisCache(options =>
        {
            options.Configuration = configuration.GetConnectionString("Redis");
        });
        
        // HybridCache
        services.AddHybridCache(options =>
        {
            options.DefaultEntryOptions = new HybridCacheEntryOptions
            {
                Expiration = TimeSpan.FromHours(1),
                LocalCacheExpiration = TimeSpan.FromMinutes(5),
                Flags = HybridCacheEntryFlags.DisableUnderlyingData // 可选：禁用某些功能
            };
            
            options.MaximumKeyLength = 512;
            options.MaximumPayloadBytes = 1024 * 1024; // 1MB
        });
        
        return services;
    }
}

public interface ICacheService
{
    Task<T?> GetOrSetAsync<T>(string key, Func<CancellationToken, Task<T?>> factory,
        TimeSpan? duration = null, CancellationToken ct = default);
    Task RemoveAsync(string key, CancellationToken ct = default);
    Task RemoveByPrefixAsync(string prefix, CancellationToken ct = default);
}

public class FusionCacheService : ICacheService
{
    private readonly IFusionCache _cache;
    private readonly ILogger<FusionCacheService> _logger;
    
    public FusionCacheService(IFusionCache cache, ILogger<FusionCacheService> logger)
    {
        _cache = cache;
        _logger = logger;
    }
    
    public async Task<T?> GetOrSetAsync<T>(string key, Func<CancellationToken, Task<T?>> factory,
        TimeSpan? duration = null, CancellationToken ct = default)
    {
        return await _cache.GetOrSetAsync(
            key,
            factory,
            duration.HasValue
                ? new FusionCacheEntryOptions { Duration = duration.Value }
                : null,
            ct
        );
    }
    
    public async Task RemoveAsync(string key, CancellationToken ct = default)
    {
        await _cache.RemoveAsync(key, token: ct);
        _logger.LogDebug("Cache removed: {Key}", key);
    }
    
    public async Task RemoveByPrefixAsync(string prefix, CancellationToken ct = default)
    {
        // FusionCache 不直接支持前缀删除
        // 需要结合 Redis SCAN 命令或使用标签
        _logger.LogWarning("RemoveByPrefix not implemented for FusionCache");
    }
}