.Net Core中的内存缓存实现——Redis及MemoryCache（2个可选）方案的实现

已于 2024-07-17 17:35:39 修改
阅读量1.1k 收藏 12
点赞数 24
分类专栏： .Net 文章标签： 缓存 redis MemoryCache IMemoryCache .netcore
于 2024-07-17 17:21:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/carcarrot/article/details/140497673
版权

ASP.NET Core 支持多个不同的缓存。 最简单的缓存基于 IMemoryCache。 IMemoryCache 表示存储在 Web 服务器内存中的缓存。 在服务器场（多个服务器）中运行的应用应确保在使用内存中缓存时会话是粘滞的。 粘滞会话可确保来自客户端的请求都转到同一服务器。 例如，Azure Web 应用使用应用程序请求路由 (ARR) 将所有请求路由到同一服务器。Web 场中的非粘滞会话需要分布式缓存(如 Redis)来避免缓存一致性问题。

.NET 中有两个MemoryCache类:

引自官方说明：ASP.NET Core 中的内存中缓存 | Microsoft Learn

.NET Core中使用MemoryCache

调用自带的AddMemoryCache扩展方法，将IMemoryCache注入容器中，后面便可通过容器获取IMemoryCache的实现MemoryCache对本机内存缓存进行操纵

using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
builder.Services.AddMemoryCache();   //会注入IMemoryCache的实现类MemoryCache
using IHost host = builder.Build();

封装内存缓存工具类 

以下给出代码，通过对 ICacheTool接口 的两种实现，分别封装“本地MemoryCache”和“分布式Redis”两种方案的内存缓存实现，项目中根据需要选择一种作为 ICacheTool 的实现注入依赖容器即可。

1. MemoryCacheTool:

using Microsoft.Extensions.Caching.Memory;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using ZhonTai.Common.Extensions;

namespace ZhonTai.Admin.Tools.Cache;

/// <summary>
/// 内存缓存
/// </summary>
public partial class MemoryCacheTool : ICacheTool
{
    private static readonly string PatternRegex = @"\{.*\}";

    private readonly IMemoryCache _memoryCache;
    public MemoryCacheTool(IMemoryCache memoryCache)
    {
        _memoryCache = memoryCache;
    }

    public List<string> Keys => GetAllKeys();

    public long Del(params string[] key)
    {
        foreach (var k in key)
        {
            _memoryCache.Remove(k);
        }
        return key.Length;
    }

    public Task<long> DelAsync(params string[] key)
    {
        foreach (var k in key)
        {
            _memoryCache.Remove(k);
        }

        return Task.FromResult(key.Length.ToLong());
    }

    public async Task<long> DelByPatternAsync(string pattern)
    {
        if (pattern.IsNull())
            return default;

        pattern = Regex.Replace(pattern, PatternRegex, "(.*)");

        var keys = GetAllKeys().Where(k => Regex.IsMatch(k, pattern));

        if (keys != null && keys.Count() > 0)
        {
            return await DelAsync(keys.ToArray());
        }

        return default;
    }

    public bool Exists(string key)
    {
        return _memoryCache.TryGetValue(key, out _);
    }

    public Task<bool> ExistsAsync(string key)
    {
        return Task.FromResult(_memoryCache.TryGetValue(key, out _));
    }

    public string Get(string key)
    {
        return _memoryCache.Get(key)?.ToString();
    }

    public T Get<T>(string key)
    {
        return _memoryCache.Get<T>(key);
    }

    public Task<string> GetAsync(string key)
    {
        return Task.FromResult(Get(key));
    }

    public Task<T> GetAsync<T>(string key)
    {
        return Task.FromResult(Get<T>(key));
    }

    public void Set(string key, object value)
    {
        _memoryCache.Set(key, value);
    }

    public void Set(string key, object value, TimeSpan expire)
    {
        _memoryCache.Set(key, value, expire);
    }

    public Task SetAsync(string key, object value, TimeSpan? expire = null)
    {
        if(expire.HasValue)
        {
            Set(key, value, expire.Value);
        }
        else
        {
            Set(key, value);
        }
        return Task.CompletedTask;
    }

    public async Task<T> GetOrSetAsync<T>(string key, Func<Task<T>> func, TimeSpan? expire = null)
    {
        if (await ExistsAsync(key))
        {
            try
            {
                return await GetAsync<T>(key);
            }
            catch
            {
                await DelAsync(key);
            }
        }

        var result = await func.Invoke();

        if (expire.HasValue)
        {
            await SetAsync(key, result, expire.Value);
        }
        else
        {
            await SetAsync(key, result);
        }

        return result;
    }

    private List<string> GetAllKeys()
    {
        const BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic;
        var coherentState = _memoryCache.GetType().GetField("_coherentState", flags).GetValue(_memoryCache);
        var entries = coherentState.GetType().GetField("_entries", flags).GetValue(coherentState);
        var cacheItems = entries as IDictionary;
        var keys = new List<string>();
        if (cacheItems == null) return keys;
        foreach (DictionaryEntry cacheItem in cacheItems)
        {
            keys.Add(cacheItem.Key.ToString());
        }
        return keys;
    }

    public List<string> GetKeysByPattern(string pattern)
    {
        return GetAllKeys().Where(k => Regex.IsMatch(k, pattern)).ToList();
    }
}

2. RedisCacheTool: 

using FreeRedis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using ZhonTai.Common.Extensions;

namespace ZhonTai.Admin.Tools.Cache;

/// <summary>
/// Redis缓存
/// </summary>
public partial class RedisCacheTool : ICacheTool
{
    private static readonly string PatternRegex = @"\{.*\}";

    private readonly RedisClient _redisClient;

    public List<string> Keys => _redisClient.Keys("*").ToList();

    public RedisCacheTool(RedisClient redisClient)
    {
        _redisClient = redisClient;
    }
    public long Del(params string[] key)
    {
        return _redisClient.Del(key);
    }

    public Task<long> DelAsync(params string[] key)
    {
        return _redisClient.DelAsync(key);
    }

    public async Task<long> DelByPatternAsync(string pattern)
    {
        if (pattern.IsNull())
            return default;

        pattern = Regex.Replace(pattern, PatternRegex, "*");

        var keys = await _redisClient.KeysAsync(pattern);
        if (keys != null && keys.Length > 0)
        {
            return await _redisClient.DelAsync(keys);
        }

        return default;
    }

    public bool Exists(string key)
    {
        return _redisClient.Exists(key);
    }

    public Task<bool> ExistsAsync(string key)
    {
        return _redisClient.ExistsAsync(key);
    }

    public string Get(string key)
    {
        return _redisClient.Get(key);
    }

    public T Get<T>(string key)
    {
        return _redisClient.Get<T>(key);
    }

    public Task<string> GetAsync(string key)
    {
        return _redisClient.GetAsync(key);
    }

    public Task<T> GetAsync<T>(string key)
    {
        return _redisClient.GetAsync<T>(key);
    }

    public void Set(string key, object value)
    {
        _redisClient.Set(key, value);
    }

    public void Set(string key, object value, TimeSpan expire)
    {
        _redisClient.Set(key, value, expire);
    }

    public Task SetAsync(string key, object value, TimeSpan? expire = null)
    {
        return _redisClient.SetAsync(key, value, expire.HasValue ? expire.Value.TotalSeconds.ToInt() : 0);
    }

    public async Task<T> GetOrSetAsync<T>(string key, Func<Task<T>> func, TimeSpan? expire = null)
    {
        if (await _redisClient.ExistsAsync(key))
        {
            try
            {
                return await _redisClient.GetAsync<T>(key);
            }
            catch
            {
                await _redisClient.DelAsync(key);
            }
        }

        var result = await func.Invoke();

        await _redisClient.SetAsync(key, result, expire.HasValue ? expire.Value.TotalSeconds.ToInt() : 0);

        return result;
    }

    public List<string> GetKeysByPattern(string pattern)
    {
        return _redisClient.Keys(pattern).ToList();
    }
}

3. 根据配置选择其中一种内存缓存方案，作为ICacheTool接口的实现注入容器

...

//缓存操作类相关注册
var cacheConfig = AppInfo.GetOptions<CacheConfig>(); //获取缓存相关配置

//调用自带的AddMemoryCache扩展方法，将IMemoryCache注入容器（用于MemoryCache作为内存缓存的方案）
services.AddMemoryCache();

if (cacheConfig.Type == CacheType.Redis)
{
    //【要使用Redis作为内存缓存的实现方案】
    //FreeRedis客户端
    var redis = new RedisClient(cacheConfig.Redis.ConnectionString)
    {
        Serialize = JsonConvert.SerializeObject,
        Deserialize = JsonConvert.DeserializeObject
    };
    services.AddSingleton(redis);
    services.AddSingleton<IRedisClient>(redis);
    //Redis缓存
    services.AddSingleton<ICacheTool, RedisCacheTool>();
    //分布式Redis缓存
    services.AddSingleton<IDistributedCache>(new DistributedCache(redis));
    if(_hostAppOptions?.ConfigureIdGenerator != null)
    {
        _hostAppOptions?.ConfigureIdGenerator?.Invoke(appConfig.IdGenerator);
        YitIdHelper.SetIdGenerator(appConfig.IdGenerator);
    }
    else
    {
        //分布式Id生成器
        services.AddIdGenerator();
    }
}
else
{
    //【要使用MemoryCache作为内存缓存的实现方案】
    //内存缓存
    services.AddSingleton<ICacheTool, MemoryCacheTool>();
    //分布式内存缓存
    services.AddDistributedMemoryCache();
    //Id生成器
    _hostAppOptions?.ConfigureIdGenerator?.Invoke(appConfig.IdGenerator);
    YitIdHelper.SetIdGenerator(appConfig.IdGenerator);
}

4. CacheConfig参考配置信息：

{
  "CacheConfig": {
    //缓存类型 Memory = 0,Redis = 1
    "type": "Memory",
    //限流缓存类型 Memory = 0,Redis = 1
    "typeRateLimit": "Memory",
    //Redis配置
    "redis": {
      //连接字符串
      "connectionString": "127.0.0.1:6379,password=,defaultDatabase=1",
      //限流连接字符串
      "connectionStringRateLimit": "127.0.0.1:6379,password=,defaultDatabase=1"
    }
  }
}

相关知识记录：

封装System.Runtime.Caching.MemoryCache实现服务端缓存，以及在依赖注入中使用时要注意的坑-CSDN博客

carcarrot
关注
  • 24
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CacheCow：在.NET Core和4.5.2+中为客户端和服务器实现HTTP缓存的实现
02-03
CacheCow .NET Core和4.52+中针对HttpClient，ASP.NET Web API，ASP.NET MVC Core和的HTTP缓存的实现。 本文档涵盖以下主题： 入门： 注意：版本2.0.0中的重大更改 由于CacheCow的服务器端实现中有很多更改，而客户端的大部分保持不变。 因此，如果您过去曾经使用过CacheCow.Server并且想要迁移，请进一步阅读有关迁移的指南。 CacheCow.Client进行了一些更改，这些更改可能会或可能不会破坏您的代码（取决于您是否使用过.NET 4.5软件包），其中包括： 现在所有接口都完全异步 许多高速缓存存储不再维护和可用，包括：MongoDb，Memcached，文件和Elasticsearch。 目前仅支持Redis，SQL和InMemory，但如果您要添加存储，我可以接受PR。 ICacheStore实现可选地支持不再支持的缓存配额管理接口。 将CacheCow客户端标头从“ x-cachecow”重命名为“ x-cachecow-client” CacheCow.Client现在将从服务器接收的
ASP.NET Core 性能优化-缓存
黑夜中的潜行者
08-07 1023
ASP.NET Core 性能优化 缓存 ASP.NET Core 客户端缓存 ASP.NET Core 服务端缓存 服务器端响应缓存很鸡肋 内存缓存（In-memory cache） 缓存的过期时间策略 过期时间的两种策略 绝对过期时间 滑动过期时间 两种过期时间混用 内存缓存过期时间策略使用机制 缓存穿透问题 缓存雪崩问题 内存缓存操作帮助类 分布式缓存 Redis 用法 分布式缓存操作帮助类 随机数生成扩展方法...
.NET Core系系列列之之MemoryCache 初初识识
最新发布
qq_36078699的博客
06-29 316
Cache是一个绝大多数项目会用到的一个技术，说起到缓存可能就联想到 Set、Add、Get、Remove、Clear 这几个方法。Set 设置一个新的缓存条目（相同key的会被移除）就好像被set的这个key是一个完全新的东西，所以也不会继承之前的过期。Cache是一个绝大多数项目会用到的一个技术，这篇文章主要介绍了.NET Core系列之MemoryCache 初识，MSCache跟Orchard中的Caching非常的相识，或者说借鉴了Orchard中良好的Caching重构而来。
ASP.NET Core MemoryCache 缓存
KingCruel的专栏
10-28 820
ASP.NET Core 中的缓存内存 ASP.NET Core 中的分布式缓存（SQL Server 和 Redis 分布式缓存） 响应缓存在 ASP.NET Core 中的中间件 github 地址 IMemoryCache Interface Memcached 教程 | 菜鸟教程 管理 NuGet 程序包：Microsoft.Extensions.Caching.Memory ...
.NET Core系列之MemoryCache 缓存过期
01-03
在上一篇”拥抱.NET Core系列：MemoryCache 初识”中我们基本了解了缓存的添加、删除、获取，那么今天我们来看看缓存的过期机制。这里和上篇一样将把“Microsoft.Extensions.Caching.Memory”简称为MSCache。 MSCache项目 MSCache目前最新的正式版是 2.0.0，预览版是2.1.0，会与.NETCore 2.1一起发布。本篇用了2.0.0版本 开源在GitHub上，仓库地址是：https://github.com/aspnet/Caching NuGet地址为：https://www.nuget.org/packages/Micros
.net core 的缓存方案
主宰
06-29 590
Redis也有多种，我使用过ServiceStack.Redis和StackExchange.Reids，这两个的区别也是很大的ServiceStack.Redis是商用的，不给钱每个小时的使用是有限的，好像是六千次，但是速度稍微比StackExchange.Reids快一点点，毕竟是收费的，但是StackExchange.Reids没有使用限制，所以这里主要讲一下StackExchange.Reids怎么用。写到需要使用缓存的项目的appsettings.json里面​​​​​​​。
.net core中使用缓存之MemoryCache（本机内存）
热门推荐
火焰
11-07 1万+
环境：.net core2.2 nugt包依赖： 1. Microsoft.Extensions.Caching.Abstractions 2. Microsoft.Extensions.Caching.Memory **代码：CacheManager ** using Microsoft.Extensions.Caching.Memory; using System; using System...
.NET Core内存缓存的理解和使用以及过期时间策略
zhmen的博客
01-03 1786
ASP.NET Core内存缓存的学习和使用
.NET Core集成内存缓存
菜鸟厚非
07-04 2137
ASP.NET Core 是一个轻量级，模块化的框架，在 ASP.NET Core 中并没有内置 Cache 对象。使用需要安装包。
.NET Core2.0+MVC 用Redis/Memory+cookie实现的sso单点登录
04-12
在.NET Core 2.0和MVC中实现SSO，我们可以利用Cookie中间件来处理用户的身份验证状态，并通过分布式缓存（如Redis或Memory Cache）来共享用户身份信息。 Redis是一款高性能的键值数据库，常用于做分布式缓存。在SSO...
.NET.CORE验证码存入缓存.rar
05-28
.NET CORE提供了多种缓存机制，包括内存缓存、分布式缓存等。内存缓存适用于小型应用，而分布式缓存（如Redis或SQL Server）适合多服务器环境。在本例中，我们将使用内存缓存，因为它简单且快速。使用`Microsoft....
加速ASP.NET Core WEB API应用程序。 第三部分
04-11
在本篇讨论中，我们将深入探讨如何加速ASP.NET Core WEB API应用程序，这是系列教程的第三部分。我们将重点关注代码重构和优化，以提升性能并改善整体架构。以下是一些关键的知识点，涵盖了C#、.NET Core、.NET LINQ...
21-08-16_Nop_4.40.3(014_内存缓存配置实现).rar
08-25
MemoryCache是.NET Core内置的内存缓存，适用于小型项目；对于大型、高并发的电子商务网站，Redis或Memcached可能更合适，因为它们支持分布式缓存，能处理更多数据并提供更好的性能。 3. **缓存策略配置**：...
ASP.NET Core - 缓存之内存缓存
2301_76429513的博客
07-27 796
缓存指的是在软件应用运行过程中，将一些数据生成副本直接进行存取，而不是从原始源（数据库，业务逻辑计算等）读取数据，减少生成内容所需的工作，从而显著提高应用的性能和可伸缩性，使用好缓存技术，有利于提高我们提升用户体验性。除了 TryGetValue 方法外，如果你确定缓存中一定存在相应的数据，还可以通过 Get 方法获取数据，Get 方法支持泛型，可以直接进行类型转换，但是如果缓存中不存在该缓存项，则会返回对应类型的默认值。通过控制台打印结果，可以看到，当前时间已经改变，但是缓存的时间是之前的数据。
.net core之内存缓存
shanshan2099的专栏
11-20 510
IMemoryCache和IDistributedCache用于缓存的内置机制，所有其他技术都是从这两个接口实现。 其中IMemoryCache将被用于告诉缓存的基础，却不是唯一可用于缓存的办法，存在拓展各种丰富的api并极大地促进其作用 缓存API： 使用IMemoryCache存储和检索项目，要使用Set（）方法写入方法，从缓存中检索对象使用Get（）方法。如果不确定缓存中是否存在特定的密钥，则可以使用TryGetValue（）提前判断，返会布尔值。另一种方法GetOnCreate（）方法验证所需
.NET Core 的缓存篇之MemoryCache
weixin_34240657的博客
08-14 920
前言 对于缓存我们都已经很熟悉了,缓存分为很多种，浏览器缓存、试图缓存、服务器缓存、数据库缓存等等一些，那今天我们先介绍一下视图缓存和MemoryCache内存缓存的概念和用法： 视图缓存 在老的版本的MVC里面，有一种可以缓存视图的特性(OutputCache)，可以保持同一个参数的请求，在N段时间内，直接从mvc的缓存中读取，不去走视图的逻辑。 /...
ASP.NETCore中的缓存
qq_71012549的博客
12-29 544
1.语句[ResponseCache(Duration = 要缓存的时间)]
.net core Memcached使用
bahongying2053的博客
04-03 715
首先,你要在你电脑上安装配置好Memcached环境哦 Startup类的ConfigureServices中加入 //memcachedcore1 services.AddEnyimMemcached(options => Configuration.GetSection("enyimMemcached").Bind(options)); Configur...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值