自从使用Asp.net Core2.0 以来，不停摸索，查阅资料，这方面的资料是真的少，因此，在前人的基础上，摸索出了Asp.net Core2.0 缓存 MemoryCache 和 Redis的用法，并实现了简单的封装
那么，先给出几个参考资料吧
关于两种缓存：https://www.cnblogs.com/yuangang/p/5800113.html
关于redis持久化：https://blog.csdn.net/u010785685/article/details/52366977
两个nuget包，不用多说
接下来，贴出代码
首先在startup，我读取了appstting.json的数据，作为redis的配置
using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; using Application.Common; using Application.Common.CommonObject; using Application.CoreWork; using Application.DAL; using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.DependencyInjection; namespace Application.web { public class Startup { public Startup(IConfiguration configuration) { Configuration = configuration; } public IConfiguration Configuration { get; } // This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { Connection.MySqlConnection = Configuration.GetConnectionString("MySqlConnection"); Connection.SqlConnection = Configuration.GetConnectionString("SqlConnection"); RedisConfig.Connection = Configuration.GetSection("RedisConfig")["Connection"]; RedisConfig.DefaultDatabase =Convert.ToInt32( Configuration.GetSection("RedisConfig")["DefaultDatabase"]); RedisConfig.InstanceName = Configuration.GetSection("RedisConfig")["InstanceName"]; CommonManager.CacheObj.GetMessage<RedisCacheHelper>(); services.AddMvc(); } // This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { if (env.IsDevelopment()) { app.UseBrowserLink(); app.UseDeveloperExceptionPage(); } else { app.UseExceptionHandler("/Home/Error"); } app.UseStaticFiles(); app.UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); }); } } }
再贴上配置
"RedisConfig": {
"Connection": "127.0.0.1:6379",
"DefaultDatabase": 0,
"InstanceName": "Redis1"
},
用来放配置信息的静态类
using System; using System.Collections.Generic; using System.Text; namespace Application.Common { public static class RedisConfig { public static string configname { get; set; } public static string Connection { get; set; } public static int DefaultDatabase { get; set; } public static string InstanceName { get; set; } } }
然后ICacheHelper.cs，这个类是两种缓存通用的接口，让使用更方便
using System; using System.Collections.Generic; using System.Net; using System.Text; namespace Application.Common.CommonObject { public interface ICacheHelper { bool Exists(string key); T GetCache<T>(string key) where T : class; void SetCache(string key, object value); void SetCache(string key, object value, DateTimeOffset expiressAbsoulte);//设置绝对时间过期 void SetSlidingCache(string key, object value, TimeSpan t); //设置滑动过期， 因redis暂未找到自带的滑动过期类的API，暂无需实现该接口 void RemoveCache(string key); void KeyMigrate(string key, EndPoint endPoint,int database,int timeountseconds); void Dispose(); void GetMssages(); void Publish(string msg); } }
然后，实现接口，首先是MemoryCacheHelper
using Microsoft.Extensions.Caching.Memory; using System; using System.Collections.Generic; using System.Net; using System.Text; namespace Application.Common.CommonObject { public class MemoryCacheHelper : ICacheHelper { //public MemoryCacheHelper(/*MemoryCacheOptions options*/)//这里可以做成依赖注入，但没打算做成通用类库，所以直接把选项直接封在帮助类里边 //{ // //this._cache = new MemoryCache(options); // //this._cache = new MemoryCache(new MemoryCacheOptions()); //} //public MemoryCacheHelper(MemoryCacheOptions options)//这里可以做成依赖注入，但没打算做成通用类库，所以直接把选项直接封在帮助类里边 //{ // this._cache = new MemoryCache(options); //} public static IMemoryCache _cache=new MemoryCache(new MemoryCacheOptions()); /// <summary> /// 是否存在此缓存 /// </summary> /// <param name="key"></param> /// <returns></returns> public bool Exists(string key) { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); object v = null; return _cache.TryGetValue<object>(key, out v); } /// <summary> /// 取得缓存数据 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key"></param> /// <returns></returns> public T GetCache<T>(string key) where T : class { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); T v = null; _cache.TryGetValue<T>(key, out v); return v; } /// <summary> /// 设置缓存 /// </summary> /// <param name="key"></param> /// <param name="value"></param> public void SetCache(string key, object value) { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); if (value == null) throw new ArgumentNullException(nameof(value)); object v = null; if (_cache.TryGetValue(key, out v)) _cache.Remove(key); _cache.Set<object>(key, value); } /// <summary> /// 设置缓存,绝对过期 /// </summary> /// <param name="key"></param> /// <param name="value"></param> /// <param name="expirationMinute">间隔分钟</param> /// CommonManager.CacheObj.Save<RedisCacheHelper>("test", "RedisCache works!", 30); public void SetCache(string key, object value, double expirationMinute) { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); if (value == null) throw new ArgumentNullException(nameof(value)); object v = null; if (_cache.TryGetValue(key, out v)) _cache.Remove(key); DateTime now = DateTime.Now; TimeSpan ts = now.AddMinutes(expirationMinute) - DateTime.Now; _cache.Set<object>(key, value, ts); } /// <summary> /// 设置缓存,绝对过期 /// </summary> /// <param name="key"></param> /// <param name="value"></param> /// <param name="expirationTime">DateTimeOffset 结束时间</param> /// CommonManager.CacheObj.Save<RedisCacheHelper>("test", "RedisCache works!", DateTimeOffset.Now.AddSeconds(30)); public void SetCache(string key, object value, DateTimeOffset expirationTime) { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); if (value == null) throw new ArgumentNullException(nameof(value)); object v = null; if (_cache.TryGetValue(key, out v)) _cache.Remove(key); _cache.Set<object>(key, value, expirationTime); } /// <summary> /// 设置缓存,相对过期时间 /// </summary> /// <param name="key"></param> /// <param name="value"></param> /// <param name="t"></param> /// CommonManager.CacheObj.SaveSlidingCache<MemoryCacheHelper>("test", "MemoryCache works!",TimeSpan.FromSeconds(30)); public void SetSlidingCache(string key,object value,TimeSpan t) { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); if (value == null) throw new ArgumentNullException(nameof(value)); object v = null; if (_cache.TryGetValue(key, out v)) _cache.Remove(key); _cache.Set(key, value, new MemoryCacheEntryOptions() { SlidingExpiration=t }); } /// <summary> /// 移除缓存 /// </summary> /// <param name="key"></param> public void RemoveCache(string key) { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); _cache.Remove(key); } /// <summary> /// 释放 /// </summary> public void Dispose() { if (_cache != null) _cache.Dispose(); GC.SuppressFinalize(this); } public void KeyMigrate(string key, EndPoint endPoint, int database, int timeountseconds) { throw new NotImplementedException(); } public void GetMssages() { throw new NotImplementedException(); } public void Publish(string msg) { throw new NotImplementedException(); } } }
然后是RedisCacheHelper
using Microsoft.Extensions.Caching.Redis; using Newtonsoft.Json; using StackExchange.Redis; using System; using System.Collections.Generic; using System.Net; using System.Text; namespace Application.Common.CommonObject { public class RedisCacheHelper : ICacheHelper { public RedisCacheHelper(/*RedisCacheOptions options, int database = 0*/)//这里可以做成依赖注入，但没打算做成通用类库，所以直接把连接信息直接写在帮助类里 { options = new RedisCacheOptions(); options.Configuration = "127.0.0.1:6379";//RedisConfig.Connection; options.InstanceName = RedisConfig.InstanceName; int database = RedisConfig.DefaultDatabase; _connection = ConnectionMultiplexer.Connect(options.Configuration); _cache = _connection.GetDatabase(database); _instanceName = options.InstanceName; _sub = _connection.GetSubscriber(); } public static RedisCacheOptions options; public static IDatabase _cache; public static ConnectionMultiplexer _connection; public static string _instanceName; public static ISubscriber _sub; /// <summary> /// 取得redis的Key名称 /// </summary> /// <param name="key"></param> /// <returns></returns> private string GetKeyForRedis(string key) { return _instanceName + key; } /// <summary> /// 判断当前Key是否存在数据 /// </summary> /// <param name="key"></param> /// <returns></returns> public bool Exists(string key) { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); return _cache.KeyExists(GetKeyForRedis(key)); } /// <summary> /// 取得缓存数据 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key"></param> /// <returns></returns> public T GetCache<T>(string key) where T : class { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); var value = _cache.StringGet(GetKeyForRedis(key)); if (!value.HasValue) return default(T); return JsonConvert.DeserializeObject<T>(value); } /// <summary> /// 设置缓存数据 /// </summary> /// <param name="key"></param> /// <param name="value"></param> public void SetCache(string key, object value) { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); if (value == null) throw new ArgumentNullException(nameof(value)); if (Exists(GetKeyForRedis(key))) RemoveCache(GetKeyForRedis(key)); _cache.StringSet(GetKeyForRedis(key), JsonConvert.SerializeObject(value)); } /// <summary> /// 设置绝对过期时间 /// </summary> /// <param name="key"></param> /// <param name="value"></param> /// <param name="expiressAbsoulte"></param> public void SetCache(string key, object value, DateTimeOffset expiressAbsoulte) { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); if (value == null) throw new ArgumentNullException(nameof(value)); if (Exists(GetKeyForRedis(key))) RemoveCache(GetKeyForRedis(key)); TimeSpan t = expiressAbsoulte - DateTimeOffset.Now; _cache.StringSet(GetKeyForRedis(key), JsonConvert.SerializeObject(value), t); } /// <summary> /// 设置相对过期时间 /// </summary> /// <param name="key"></param> /// <param name="value"></param> /// <param name="expirationMinute"></param> public void SetCache(string key, object value, double expirationMinute) { if (Exists(GetKeyForRedis(key))) RemoveCache(GetKeyForRedis(key)); DateTime now = DateTime.Now; TimeSpan ts = now.AddMinutes(expirationMinute) - now; _cache.StringSet(GetKeyForRedis(key), JsonConvert.SerializeObject(value), ts); } /// <summary> /// /// </summary> /// <param name="key"></param> /// <param name="endPoint"></param> /// <param name="database"></param> /// <param name="timeountseconds"></param> public void KeyMigrate(string key, EndPoint endPoint, int database, int timeountseconds) { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); _cache.KeyMigrate(GetKeyForRedis(key), endPoint, database, timeountseconds); } /// <summary> /// 移除redis /// </summary> /// <param name="key"></param> public void RemoveCache(string key) { if (string.IsNullOrWhiteSpace(key)) throw new ArgumentNullException(nameof(key)); _cache.KeyDelete(GetKeyForRedis(key)); } /// <summary> /// 销毁连接 /// </summary> public void Dispose() { if (_connection != null) _connection.Dispose(); GC.SuppressFinalize(this); } public void SetSlidingCache(string key, object value, TimeSpan t) { throw new NotImplementedException(); } public void GetMssages() { using (_connection = ConnectionMultiplexer.Connect(options.Configuration)) _sub.Subscribe("msg", (channel, message) => { string result = message; }); } public void Publish(string msg) { using (_connection=ConnectionMultiplexer.Connect(options.Configuration)) _sub.Publish("msg", msg); } } }
然后是Cache.cs,用来实例化，此处用单例模式，保证项目使用的是一个缓存实例，博主吃过亏，由于redis实例过多，构造函数运行太多次，导致client连接数过大，内存不够跑，速度卡慢
using System; using System.Collections.Generic; using System.Text; namespace Application.Common.CommonObject { public sealed class Cache { internal Cache() { } public static ICacheHelper cache; /// <summary> /// 判断缓存是否存在 /// </summary> /// <typeparam name="CacheType">缓存类型</typeparam> /// <param name="key">键名</param> /// <returns></returns> public bool Exists<CacheType>(string key) where CacheType : ICacheHelper, new() { if (cache!=null&& typeof(CacheType).Equals(cache.GetType())) return cache.Exists(key); else { cache = new CacheType(); return cache.Exists(key); } } /// <summary> /// 获取缓存 /// </summary> /// <typeparam name="T">转换的类</typeparam> /// <typeparam name="CacheType">缓存类型</typeparam> /// <param name="key">键名</param> /// <returns>转换为T类型的值</returns> public T GetCache<T,CacheType>(string key) where T:class where CacheType : ICacheHelper, new() { if (cache != null && typeof(CacheType).Equals(cache.GetType())) return cache.GetCache<T>(key); else { cache = new CacheType(); return cache.GetCache<T>(key); } } /// <summary> /// 保存缓存 /// </summary> /// <typeparam name="CacheType">缓存类型</typeparam> /// <param name="key">键名</param> /// <param name="value">值</param> public void Save<CacheType>(string key,object value) where CacheType : ICacheHelper, new() { if (cache != null && typeof(CacheType).Equals(cache.GetType())) cache.SetCache(key, value); else { cache = new CacheType(); cache.SetCache(key, value); } } /// <summary> /// 保存缓存并设置绝对过期时间 /// </summary> /// <typeparam name="CacheType">缓存类型</typeparam> /// <param name="key">键名</param> /// <param name="value">值</param> /// <param name="expiressAbsoulte">绝对过期时间</param> public void Save<CacheType>(string key, object value, DateTimeOffset expiressAbsoulte) where CacheType : ICacheHelper, new() { if (cache != null && typeof(CacheType).Equals(cache.GetType())) cache.SetCache(key, value, expiressAbsoulte); else { cache = new CacheType(); cache.SetCache(key, value, expiressAbsoulte); } } /// <summary> /// 保存滑动缓存 /// </summary> /// <typeparam name="CacheType">只能用memorycache，redis暂不实现</typeparam> /// <param name="key"></param> /// <param name="value"></param> /// <param name="t">间隔时间</param> public void SaveSlidingCache<CacheType>(string key, object value,TimeSpan t) where CacheType : MemoryCacheHelper, new() { if (cache != null && typeof(CacheType).Equals(cache.GetType())) cache.SetSlidingCache(key, value, t); else { cache = new CacheType(); cache.SetSlidingCache(key, value, t); } } /// <summary> /// 删除一个缓存 /// </summary> /// <typeparam name="CacheType">缓存类型</typeparam> /// <param name="key">要删除的key</param> public void Delete<CacheType>(string key)where CacheType : ICacheHelper, new() { if (cache != null && typeof(CacheType).Equals(cache.GetType())) cache.RemoveCache(key); else { cache = new CacheType(); cache.RemoveCache(key); } } /// <summary> /// 释放 /// </summary> /// <typeparam name="CacheType"></typeparam> public void Dispose<CacheType>() where CacheType : ICacheHelper, new() { if (cache != null && typeof(CacheType).Equals(cache.GetType())) cache.Dispose(); else { cache = new CacheType(); cache.Dispose(); } } public void GetMessage<CacheType>() where CacheType:RedisCacheHelper,new() { if (cache != null && typeof(CacheType).Equals(cache.GetType())) cache.GetMssages(); else { cache = new CacheType(); cache.GetMssages(); } } public void Publish<CacheType>(string msg)where CacheType : RedisCacheHelper, new() { if (cache != null && typeof(CacheType).Equals(cache.GetType())) cache.Publish(msg); else { cache = new CacheType(); cache.Publish(msg); } } } }
接下来，CommonManager.cs,该类主要是为了作为一个静态类调用缓存，由于Cache.cs并非静态类，方便调用
using Application.Common.CommonObject; using System; using System.Collections.Generic; using System.Text; namespace Application.Common { public class CommonManager { private static readonly object lockobj = new object(); private static volatile Cache _cache = null; /// <summary> /// Cache /// </summary> public static Cache CacheObj { get { if (_cache == null) { lock (lockobj) { if (_cache == null) _cache = new Cache(); } } return _cache; } } } }
最后呢就是使用啦随便建的一个控制器
using System; using System.Collections.Generic; using System.Linq; using System.Net; using System.Threading; using System.Threading.Tasks; using Application.Common; using Application.Common.CommonObject; using Application.CoreWork; using Microsoft.AspNetCore.Mvc; namespace Application.web.Controllers { public class DefaultController : BaseController { public IActionResult Index() { for (int i = 0; i < 100000; i++) { CommonManager.CacheObj.Save<RedisCacheHelper>("key" + i, "key" + i + " works!"); } return View(); } public IActionResult GetStrin(int index) { string res = "已经过期了"; if (CommonManager.CacheObj.Exists<RedisCacheHelper>("key" + index)) { res = CommonManager.CacheObj.GetCache<String, RedisCacheHelper>("key" + index); } return Json(new ExtJson { success = true, code = 1000, msg = "成功", jsonresult = res }); } public IActionResult Publish(string msg) { try { CommonManager.CacheObj.Publish<RedisCacheHelper>(msg); return Json(new ExtJson { success = true, code = 1000, msg = "成功", jsonresult = msg }); } catch { return Json(new ExtJson { success = true, code = 1000, msg = "失败", jsonresult = msg }); } } } }
那么，有的朋友在json处可能会报错，自己封装下，或者用原来的json吧
如果有不懂的地方，可以在评论中提问，有更好的改进方式，也请联系我，共同进步，感谢阅读
2019-5-23更新
在实际运行过程中，发现大量用户请求，并且两种缓存混合使用时，redis和memory的单例会多次创建，导致redis连接数达到上限，下面贴出修改后的cache.cs
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
namespace Application.Common.CommonObject
{
public sealed class Cache
{
internal Cache() { }
public static ICacheHelper cache;
public static RedisCacheHelper redis;
public static MemoryCacheHelper memory;
public ICacheHelper Getcachehelper<CacheType>()
{
if (typeof(CacheType).Equals(typeof(RedisCacheHelper)))
{
if (redis == null)
{
redis = new RedisCacheHelper();
Process pc = Process.GetCurrentProcess();
CommonManager.TxtObj.Log4netError("进程ID："+pc.Id+";redis为null,创建一个新的实例",typeof(Cache),null);
}
return redis;
}
else if (typeof(CacheType).Equals(typeof(MemoryCacheHelper)))
{
if (memory == null)
memory = new MemoryCacheHelper();
return memory;
}
else
return null;
}
/// <summary>
/// 判断缓存是否存在
/// </summary>
/// <typeparam name="CacheType">缓存类型</typeparam>
/// <param name="key">键名</param>
/// <returns></returns>
public bool Exists<CacheType>(string key) where CacheType : ICacheHelper, new()
{
cache = Getcachehelper<CacheType>();
return cache.Exists(key);
}
/// <summary>
/// 获取缓存
/// </summary>
/// <typeparam name="T">转换的类</typeparam>
/// <typeparam name="CacheType">缓存类型</typeparam>
/// <param name="key">键名</param>
/// <returns>转换为T类型的值</returns>
public T GetCache<T, CacheType>(string key)
where T : class
where CacheType : ICacheHelper, new()
{
cache = Getcachehelper<CacheType>();
return cache.GetCache<T>(key);
}
/// <summary>
/// 保存缓存
/// </summary>
/// <typeparam name="CacheType">缓存类型</typeparam>
/// <param name="key">键名</param>
/// <param name="value">值</param>
public void Save<CacheType>(string key, object value) where CacheType : ICacheHelper, new()
{
cache = Getcachehelper<CacheType>();
cache.SetCache(key, value);
}
/// <summary>
/// 保存缓存并设置绝对过期时间
/// </summary>
/// <typeparam name="CacheType">缓存类型</typeparam>
/// <param name="key">键名</param>
/// <param name="value">值</param>
/// <param name="expiressAbsoulte">绝对过期时间</param>
public void Save<CacheType>(string key, object value, DateTimeOffset expiressAbsoulte) where CacheType : ICacheHelper, new()
{
cache = Getcachehelper<CacheType>();
cache.SetCache(key, value, expiressAbsoulte);
}
/// <summary>
/// 保存滑动缓存
/// </summary>
/// <typeparam name="CacheType">只能用memorycache，redis暂不实现</typeparam>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="t">间隔时间</param>
public void SaveSlidingCache<CacheType>(string key, object value, TimeSpan t) where CacheType : MemoryCacheHelper, new()
{
cache = Getcachehelper<CacheType>();
cache.SetSlidingCache(key, value, t);
}
/// <summary>
/// 删除一个缓存
/// </summary>
/// <typeparam name="CacheType">缓存类型</typeparam>
/// <param name="key">要删除的key</param>
public void Delete<CacheType>(string key) where CacheType : ICacheHelper, new()
{
cache = Getcachehelper<CacheType>();
cache.RemoveCache(key);
}
/// <summary>
/// 释放
/// </summary>
/// <typeparam name="CacheType"></typeparam>
public void Dispose<CacheType>() where CacheType : ICacheHelper, new()
{
cache = Getcachehelper<CacheType>();
cache.Dispose();
}
public List<string> GetCacheKeys<CacheType>() where CacheType : ICacheHelper, new()
{
cache = Getcachehelper<CacheType>();
return cache.GetCacheKeys();
}
public void GetMessage<CacheType>() where CacheType : RedisCacheHelper, new()
{
cache = Getcachehelper<CacheType>();
cache.GetMssages();
}
public void Publish<CacheType>(string msg) where CacheType : RedisCacheHelper, new()
{
cache = Getcachehelper<CacheType>();
cache.Publish(msg);
}
}
}