ASP.NET Core 中的缓存机制

[Route("api/[controller]")]
[ApiController]
public class EmployeeController : ControllerBase
{
    private readonly IMemoryCache _memoryCache;
    private readonly ApplicationContext _context;
    public EmployeeController(IMemoryCache memoryCache, ApplicationContext context)
    {
        _memoryCache = memoryCache;
        _context = context;
    }

    [HttpGet]
    public async Task<IActionResult> GetAllEmployee()
    {
        var cacheKey = "employeeList";
        //checks if cache entries exists
        if(!_memoryCache.TryGetValue(cacheKey, out List<Employee> employeeList))
        {
            //calling the server
            employeeList = await _context.Employees.ToListAsync();

            //setting up cache options
            var cacheExpiryOptions = new MemoryCacheEntryOptions
            {
                AbsoluteExpiration = DateTime.Now.AddSeconds(50),
                Priority = CacheItemPriority.High,
                SlidingExpiration = TimeSpan.FromSeconds(20)
            };
            //setting cache entries
            _memoryCache.Set(cacheKey, employeeList, cacheExpiryOptions);
        }
        return Ok(employeeList);
    }
}

这是一个非常简单的实现。我们只是检查是否有任何缓存值可用于特定缓存键。如果存在，它将从缓存中提供数据，如果不存在，我们将调用我们的服务并将数据保存在缓存中。

解释

第 9 行：将 ImemoryCache 注入构造函数

第 16 行：创建缓存键。众所周知，数据将保存为键值对。

第 18 行：检查缓存值是否可用于特定键。

第 24 行：设置缓存。MemoryCacheEntryOptions用于定义缓存的关键属性。其中一些属性是：

1. Priority – Priority 定义了在缓存中保留缓存条目的优先级。默认值设置为正常。

2. Sliding Expiration –一个特定的时间跨度，如果没有人使用，缓存将在该时间段内到期。由于我们将滑动过期时间设置为 20 秒，因此这意味着在缓存进入后，如果 20 秒内没有客户端请求，缓存将过期。

3. Absolute Expiration –指缓存条目的实际过期时间，不考虑滑动过期时间。在我们的代码中，我们将绝对过期时间设置为 50 秒。所以这意味着缓存肯定会每 50 秒过期一次。

现在让我们观察在实现内存缓存后我们的应用程序的性能提升。

为此，运行应用程序并使用 Postman 向 Web API 发送获取请求。因此，我们第一次向 API 发送请求大约需要 2061 毫秒。

因此，当我们第一次调用 API 时，它直接从数据库中获取数据，然后我们将数据并行存储到缓存中。

现在，如果我们这次为相同的数据请求相同的端点，则只需要 20 毫秒。

所以这是一个非常惊人的改进。就我而言，数据集很小。如果有大量关于这种情况的数据，它将大大改善我们的服务。

分布式缓存

分布式缓存是一种可以由一个或多个应用程序共享的缓存，它作为一种所有服务器都可以访问的外部服务进行维护。所以分布式缓存是应用程序外部的。

分布式缓存的主要优点是数据在多个服务器中保持一致，因为服务器位于应用程序外部，任何应用程序的任何故障都不会影响缓存服务器。

在这里，我们将尝试使用 Redis 实现分布式缓存。

Redis是一种开源（BSD 许可）、内存中数据结构存储，用作数据库缓存和消息代理。它是非常快速的基于键值的数据库，甚至是 NoSQL 数据库。所以Redis是实现高可用缓存的绝佳选择。

在 Docker 中设置 Redis

第1步

从 docker hub 拉取 docker Redis 镜像。

docker pull redis

第2步

通过将 Redis 端口映射到我们的本地系统端口来运行 Redis 镜像。

docker run --name myrediscache -p 5003:379 -d redis

第 3 步

启动容器。

docker start myrediscache

现在我们的 Redis 已经设置好了，让我们开始使用 ASP.NET Core 应用程序实现分布式缓存。

使用 ASP.NET Core 实现分布式缓存（Redis）

创建一个 ASP.NET Core Web API 项目并使用 Nuget 包管理器安装以下库。

由于我们已经添加了所需的包，现在在Startup.cs文件中注册服务。

public void ConfigureServices(IServiceCollection services) {
    //Rest of the code
    services.AddStackExchangeRedisCache(options => {
        options.Configuration = Configuration.GetConnectionString("Redis");
        options.InstanceName = "localRedis_";
    });
}

{
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "Redis": "localhost:5003",
    "DefaultConnection": "Data Source=.;Initial Catalog=BuildingDataDB;Integrated Security=True"
  }
}

public static class DistributedCacheExtension {
    public static async Task SetRecordAsync < T > (this IDistributedCache cache, string recodeId, T data, TimeSpan ? absoluteExpireTime = null, TimeSpan ? slidingExpirationTime = null) {
        var options = new DistributedCacheEntryOptions();
        options.AbsoluteExpirationRelativeToNow = absoluteExpireTime ?? TimeSpan.FromSeconds(60);
        options.SlidingExpiration = slidingExpirationTime;
        var jsonData = JsonSerializer.Serialize(data);
        await cache.SetStringAsync(recodeId, jsonData, options);
    }
    public static async Task < T > GetRecordAsync < T > (this IDistributedCache cache, string recordId) {
        var jsonData = await cache.GetStringAsync(recordId);
        if (jsonData is null) {
            return default (T);
        }
        return JsonSerializer.Deserialize < T > (jsonData);
    }
}

public class StudentController: ControllerBase {
    private readonly ApplicationContext _context = null;
    private readonly IDistributedCache _cache;
    public StudentController(ApplicationContext context, IDistributedCache cache) {
            _context = context;
            _cache = cache;
        }
        [HttpGet]
    public async Task < ActionResult < List < Student >>> Get() {
        var cacheKey = "GET_ALL_STUDENTS";
        List < Student > students = new List < Student > ();
        var data = await _cache.GetRecordAsync < List < Student >> (cacheKey);
        if (data is null) {
            Thread.Sleep(10000);
            data = _context.Student.ToList();
            await _cache.SetRecordAsync(cacheKey, data);
        }
        return data;
    }
}