EasyCaching 应用详解

EasyCaching 是一个开源的缓存库，它提供了统一的缓存访问接口，支持各种流行的缓存提供程序，如内存缓存、Redis、SQLite等。本文将详细介绍 EasyCaching 的使用方法和实践案例。

特性

统一的缓存操作接口
支持多种缓存提供程序
支持缓存序列化
支持缓存拦截器
支持缓存统计和监控
支持分布式缓存同步

安装必要的NuGet包

Bash
# 安装核心包
dotnet add package EasyCaching.Core

# 安装内存缓存提供程序
dotnet add package EasyCaching.InMemory

# 安装序列化包
dotnet add package EasyCaching.Serialization.Json

基础使用示例

下面是一个完整的控制台应用程序示例，展示了 EasyCaching 的基本用法：

C#
using EasyCaching.Core;
using EasyCaching.Core.Configurations;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // 创建服务集合
        IServiceCollection services = new ServiceCollection();

        // 配置EasyCaching
        services.AddEasyCaching(options =>
        {
            // 添加内存缓存
            options.UseInMemory(config =>
            {
                config.DBConfig = new InMemoryCachingOptions
                {
                    // 缓存大小限制
                    SizeLimit = 100
                };
            }, "default");
        });

        // 构建服务提供程序
        IServiceProvider serviceProvider = services.BuildServiceProvider();

        // 获取缓存工厂
        var factory = serviceProvider.GetService<IEasyCachingProviderFactory>();
        var cachingProvider = factory.GetCachingProvider("default");

        // 1. 基本的存取操作
        Console.WriteLine("===== 基本的存取操作 =====");
        
        // 设置缓存
        await cachingProvider.SetAsync("key1", "value1", TimeSpan.FromMinutes(1));
        
        // 获取缓存
        var value = await cachingProvider.GetAsync<string>("key1");
        Console.WriteLine($"key1的值: {value.Value}");

        // 2. 使用Get或Add模式
        Console.WriteLine("\n===== Get或Add模式 =====");
        
        var result = await cachingProvider.GetAsync("key2", async () =>
        {
            // 模拟从数据库获取数据
            await Task.Delay(100);
            return "从数据源获取的值";
        }, TimeSpan.FromMinutes(1));

        Console.WriteLine($"key2的值: {result.Value}");

        // 3. 删除缓存
        Console.WriteLine("\n===== 删除缓存 =====");
        
        await cachingProvider.RemoveAsync("key1");
        var checkValue = await cachingProvider.GetAsync<string>("key1");
        Console.WriteLine($"删除后key1是否存在: {checkValue.HasValue}");

        // 4. 批量操作
        Console.WriteLine("\n===== 批量操作 =====");
        
        // 批量设置
        var dict = new Dictionary<string, string>
        {
            {"batch1", "value1"},
            {"batch2", "value2"},
            {"batch3", "value3"}
        };

        await cachingProvider.SetAllAsync(dict, TimeSpan.FromMinutes(1));

        // 批量获取
        var keys = new[] { "batch1", "batch2", "batch3" };
        var batchValues = await cachingProvider.GetAllAsync<string>(keys);

        foreach (var item in batchValues)
        {
            Console.WriteLine($"键:{item.Key}, 值:{item.Value}");
        }

        // 5. 缓存过期演示
        Console.WriteLine("\n===== 缓存过期演示 =====");
        
        await cachingProvider.SetAsync("shortKey", "短期缓存", TimeSpan.FromSeconds(2));
        Console.WriteLine("等待3秒...");
        await Task.Delay(3000);
        
        var expiredValue = await cachingProvider.GetAsync<string>("shortKey");
        Console.WriteLine($"过期后是否存在值: {expiredValue.HasValue}");
    }
}

自定义对象缓存示例

下面展示如何缓存自定义类型的对象：

C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AppEasyCache
{
    // 定义一个用户类
    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
    }

}

C#
using EasyCaching.Core;
using EasyCaching.InMemory;
using Microsoft.Extensions.DependencyInjection;

namespace AppEasyCache
{
    internal class Program
    {
        static async Task Main(string[] args)
        {
            // 创建服务集合
            IServiceCollection services = new ServiceCollection();

            // 配置EasyCaching
            services.AddEasyCaching(options =>
            {
                // 添加内存缓存
                options.UseInMemory(config =>
                {
                    config.DBConfig = new InMemoryCachingOptions
                    {
                        // 缓存大小限制
                        SizeLimit = 100
                    };
                }, "default");
            });

            // 构建服务提供程序
            IServiceProvider serviceProvider = services.BuildServiceProvider();

            await CacheCustomObject(serviceProvider.GetService<IEasyCachingProviderFactory>().GetCachingProvider("default"));
        }

        // 在Main方法中添加以下代码
        static async Task CacheCustomObject(IEasyCachingProvider cachingProvider)
        {
            Console.WriteLine("\n===== 自定义对象缓存 =====");

            // 创建用户对象
            var user = new User
            {
                Id = 1,
                Name = "张三",
                Age = 25
            };

            // 缓存用户对象
            await cachingProvider.SetAsync($"user:{user.Id}", user, TimeSpan.FromMinutes(30));

            // 获取缓存的用户对象
            var cachedUser = await cachingProvider.GetAsync<User>($"user:{user.Id}");

            if (cachedUser.HasValue)
            {
                Console.WriteLine($"获取到缓存的用户: Id={cachedUser.Value.Id}, " +
                                 $"Name={cachedUser.Value.Name}, Age={cachedUser.Value.Age}");
            }
        }
    }
}

最佳实践

缓存时间设置
- 根据数据更新频率设置合适的缓存时间
- 对于不经常变化的数据可以设置较长的缓存时间
- 对于实时性要求高的数据设置较短的缓存时间
缓存键命名规范
- 使用统一的命名规范，如：模块:类型:ID
- 避免使用特殊字符
- 保持命名的可读性
异常处理
- 添加适当的异常处理机制
- 当缓存服务不可用时有降级策略

C#
public async Task<string> GetDataWithRetry(IEasyCachingProvider cachingProvider, string key)
{
    try
    {
        var cacheResult = await cachingProvider.GetAsync<string>(key);
        if (cacheResult.HasValue)
        {
            return cacheResult.Value;
        }

        // 缓存不存在，从数据源获取
        var value = await GetFromDataSource();
        await cachingProvider.SetAsync(key, value, TimeSpan.FromMinutes(30));
        return value;
    }
    catch (Exception ex)
    {
        // 记录日志
        Console.WriteLine($"缓存操作失败: {ex.Message}");
        // 降级到直接从数据源获取
        return await GetFromDataSource();
    }
}

private async Task<string> GetFromDataSource()
{
    // 模拟从数据库获取数据
    await Task.Delay(100);
    return "数据源中的值";
}

性能优化建议

合理使用批量操作
- 使用 GetAllAsync 和 SetAllAsync 代替多次单独操作
- 减少网络往返次数
使用异步方法
- 优先使用异步方法提高性能
- 避免使用同步方法阻塞线程
设置合适的缓存大小
- 根据服务器内存配置设置合适的缓存大小限制
- 监控缓存使用情况，适时调整

总结

EasyCaching 提供了强大而灵活的缓存解决方案，通过本文的示例和最佳实践，您可以在项目中更好地使用 EasyCaching。记住要根据实际业务场景选择合适的缓存策略，并注意性能优化和异常处理。

目录

特性

安装必要的NuGet包

基础使用示例

自定义对象缓存示例

最佳实践

性能优化建议

总结