<>静态字段缓存基本使用
/// <summary> /// 1 客户端缓存-CDN缓存-反向代理缓存-本地缓存 /// 2 本地缓存原理和手写基础实现 /// 3
缓存更新/过期/多线程测试 /// 4 缓存类库封装和缓存应用总结 /// </summary> /// <param name="args"></param>
static void Main(string[] args) { try { Console.WriteLine("开发进阶/蜕变架构!"); {
Console.WriteLine("***************DBHelper*****************"); for (int i = 0; i
< 5; i++) //会重复查询数据 { Console.WriteLine($"获取{nameof(DBHelper)} {i}次
{DateTime.Now.ToString("yyyyMMdd HHmmss.fff")}"); List<Program> programList =
null; string key = $"{nameof(Program)}_DBHelper.Query_{123}"; programList =
CustomCache.GetT<List<Program>>(key, () => { return DBHelper.Query<Program>(123)
; }); } } } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.Read
(); } /// <summary> ///模拟数据库查询 /// </summary> public class DBHelper { ///
<summary> /// 1 耗时耗资源 /// 2 参数固定时,结果不变 /// </summary> /// <typeparam
name="T"></typeparam> /// <param name="index"></param> /// <returns></returns>
public static List<T> Query<T>(int index) { Console.WriteLine("This is {0}
Query", typeof(DBHelper)); long lResult = 0; //耗时耗资源 for (int i = index; i < 1
_000_000_000; i++) { lResult += i; } ///只要Index不变 返回值是不变的! List<T> tList = new
List<T>(); for (int i = 0; i < index % 3; i++) { tList.Add(default(T)); } return
tList; } } public class CustomCache { /// <summary> /// 字典缓存 ///
static:不会被Gc回收; /// Private:不让外部访问他 /// </summary> private static Dictionary<
string, object> CustomCacheDictionary = new Dictionary<string, object>(); public
static void Add(string key, object value) { CustomCacheDictionary.Add(key, value
); } public static T Get<T>(string key) { return (T)CustomCacheDictionary[key];
} public static bool Exists(string key) { return CustomCacheDictionary.
ContainsKey(key); } public static T GetT<T>(string key, Func<T> func) { T t =
default(T); if (!Exists(key)) { t = func.Invoke(); Add(key, t); } else { t = Get
<T>(key); } return t; } }
<>cache缓存封装
/// <summary> /// Cache manager interface /// </summary> public interface
ICache { /// <summary> /// Gets or sets the value associated with the specified
key. /// </summary> /// <typeparam name="T">Type</typeparam> /// <param
name="key">The key of the value to get.</param> /// <returns>The value
associated with the specified key.</returns> T Get<T>(string key); /// <summary>
/// Adds the specified key and object to the cache. /// </summary> /// <param
name="key">key</param> /// <param name="data">Data</param> /// <param
name="cacheTime">Cache time</param> void Add(string key, object data, int
cacheTime= 30); /// <summary> /// Gets a value indicating whether the value
associated with the specified key is cached /// </summary> /// <param
name="key">key</param> /// <returns>Result</returns> bool Contains(string key);
/// <summary> /// Removes the value with the specified key from the cache ///
</summary> /// <param name="key">/key</param> void Remove(string key); ///
<summary> /// Clear all cache data /// </summary> void RemoveAll(); object this[
string key] { get; set; } int Count { get; } } /// <summary> ///
MemoryCacheCache /// </summary> public class MemoryCacheCache : ICache { public
MemoryCacheCache() { } protected ObjectCache Cache { get { return MemoryCache.
Default; } } /// <summary> /// 读取缓存 /// </summary> /// <typeparam
name="T"></typeparam> /// <param name="key"></param> /// <returns></returns>
public T Get<T>(string key) { if (Cache.Contains(key)) { return (T)Cache[key]; }
else { return default(T); } } public object Get(string key) { return Cache[key];
} /// <summary> /// 增加缓存 /// </summary> /// <param name="key"></param> ///
<param name="data"></param> /// <param name="cacheTime">分钟</param> public void
Add(string key, object data, int cacheTime = 30) { if (data == null) return; var
policy= new CacheItemPolicy(); policy.AbsoluteExpiration = DateTime.Now +
TimeSpan.FromMinutes(cacheTime); Cache.Add(new CacheItem(key, data), policy); }
/// <summary> /// 是否包含 /// </summary> /// <param name="key"></param> ///
<returns></returns> public bool Contains(string key) { return Cache.Contains(key
); } public int Count { get { return (int)(Cache.GetCount()); } } /// <summary>
/// 单个清除 /// </summary> /// <param name="key">/key</param> public void Remove(
string key) { Cache.Remove(key); } /// <summary> /// 正则表达式移除 /// </summary> ///
<param name="pattern">pattern</param> public void RemoveByPattern(string pattern
) { var regex = new Regex(pattern, RegexOptions.Singleline | RegexOptions.
Compiled| RegexOptions.IgnoreCase); var keysToRemove = new List<String>();
foreach (var item in Cache) if (regex.IsMatch(item.Key)) keysToRemove.Add(item.
Key); foreach (string key in keysToRemove) { Remove(key); } } /// <summary> ///
根据键值返回缓存数据 /// </summary> /// <param name="key"></param> /// <returns></returns>
public object this[string key] { get { return Cache.Get(key); } set { Add(key,
value); } } /// <summary> /// 清除全部数据 /// </summary> public void RemoveAll() {
foreach (var item in Cache) Remove(item.Key); } }
<>缓存管理中心
public class CacheManager { #region Identity private CacheManager() { } private
static ICache cache = null; static CacheManager() { Console.WriteLine(
"开始缓存的初始化....."); //可以创建不同的cache对象 cache = (ICache)Activator.CreateInstance(
typeof(MemoryCacheCache)); // 这里可以根据配置文件来选择 //cache =
(ICache)Activator.CreateInstance(typeof(CustomerCache)); } #endregion Identity #
region ICache /// <summary> /// 当前缓存数据项的个数 /// </summary> public static int
Count{ get { return cache.Count; } } /// <summary> /// 如果缓存中已存在数据项键值,则返回true
/// </summary> /// <param name="key">数据项键值</param> ///
<returns>数据项是否存在</returns> public static bool Contains(string key) { return
cache.Contains(key); } /// <summary> /// 获取缓存数据 /// </summary> /// <param
name="key"></param> /// <returns></returns> public static T GetData<T>(string
key) { return cache.Get<T>(key); } /// <summary> /// /// </summary> ///
<typeparam name="T"></typeparam> /// <param name="key">缓存的项</param> /// <param
name="acquire">没有缓存的时候获取数据的方式</param> /// <param name="cacheTime">单位分钟
默认30</param> /// <returns></returns> public static T Get<T>(string key, Func<T>
acquire, int cacheTime = 30) { if (!cache.Contains(key)) { T result = acquire.
Invoke(); cache.Add(key, result, cacheTime); } return GetData<T>(key); } ///
<summary> /// 添加缓存数据。 /// 如果另一个相同键值的数据已经存在,原数据项将被删除,新数据项被添加。 /// </summary> ///
<param name="key">缓存数据的键值</param> /// <param name="value">缓存的数据,可以为null值</param>
/// <param name="expiratTime">缓存过期时间间隔(单位:分钟)</param> public static void Add(
string key, object value, int expiratTime = 30) { if (Contains(key)) cache.
Remove(key); cache.Add(key, value, expiratTime); } /// <summary> /// 删除缓存数据项
/// </summary> /// <param name="key"></param> public static void Remove(string
key) { cache.Remove(key); } /// <summary> /// 删除所有缓存数据项 /// </summary> public
static void RemoveAll() { cache.RemoveAll(); } #endregion }
缓存优化
/// <summary> /// 永不过期:当前就是 /// 绝对过期:过了多长时间以后,就过期了 就不能用了 ///
滑动过期:设定好过期时间后,如果在有效期内使用过,就往后滑动 /// 1.Value;数据; /// 2.过期时间点: /// 3.滑动时间 ///
普通cache /// </summary> public class CustomCache { static CustomCache() //CLR调用
整个进程执行且只执行一次 { Task.Run(() => // { while (true) //死循环来判断 { try { List<string>
delKeyList= new List<string>(); lock (obj_Lock) { foreach (var key in
CustomCacheDictionary.Keys) { DataModel model = CustomCacheDictionary[key]; if (
model.Deadline < DateTime.Now && model.ObsloteType != ObsloteType.Never) {
delKeyList.Add(key); } } } delKeyList.ForEach(key => Remove(key)); } catch (
Exception ex) { Console.WriteLine(ex.Message); throw; } } }); } /// <summary>
/// static:不会被Gc回收; /// Private:不让外部访问他 /// </summary> private static Dictionary
<string, DataModel> CustomCacheDictionary = new Dictionary<string, DataModel>();
private static readonly object obj_Lock = new object(); /// <summary> ///
默认你是不过期 /// </summary> /// <param name="key"></param> /// <param
name="value"></param> public static void Add(string key, object value) { lock (
obj_Lock) CustomCacheDictionary.Add(key, new DataModel() { Value = value,
ObsloteType= ObsloteType.Never }); } /// <summary> /// 绝对过期 /// </summary> ///
<param name="key"></param> /// <param name="value"></param> /// <param
name="timeOutSecond"></param> public static void Add(string key, object value,
int timeOutSecond) //3000 { lock (obj_Lock) CustomCacheDictionary.Add(key, new
DataModel() { Value = value, ObsloteType = ObsloteType.Absolutely, Deadline =
DateTime.Now.AddSeconds(timeOutSecond) }); ; } public static void Add(string key
, object value, TimeSpan durtion) { lock (obj_Lock) CustomCacheDictionary.Add(
key, new DataModel() { Value = value, ObsloteType = ObsloteType.Relative,
Deadline= DateTime.Now.Add(durtion), Duraton = durtion }); ; ; } //清楚所有缓存,殃及池鱼!
public static void RemoveAll() { lock (obj_Lock) CustomCacheDictionary.Clear();
//字典中的所有内容全部被清理到 } public static void Remove(string key) { lock (obj_Lock)
CustomCacheDictionary.Remove(key); } public static void RemoveCondition(Func<
string, bool> func) { List<string> keyList = new List<string>(); lock (obj_Lock)
foreach (var key in CustomCacheDictionary.Keys) { if (func.Invoke(key)) {
keyList.Add(key); } } keyList.ForEach(s => Remove(s)); } public static T Get<T>(
string key) { return (T)(CustomCacheDictionary[key]).Value; } public static bool
Exists(string key) { if (CustomCacheDictionary.ContainsKey(key)) { DataModel
model= CustomCacheDictionary[key]; if (model.ObsloteType == ObsloteType.Never) {
return true; } else if (model.Deadline < DateTime.Now) // { lock (obj_Lock) {
CustomCacheDictionary.Remove(key); return false; } } else { if (model.
ObsloteType== ObsloteType.Relative) { model.Deadline = DateTime.Now.Add(model.
Duraton); } return true; } } else { return false; } } public static T GetT<T>(
string key, Func<T> func) { T t = default(T); if (!Exists(key)) { t = func.
Invoke(); Add(key, t); } else { t = Get<T>(key); } return t; } } /// <summary>
/// 线程安全cache /// </summary> public class CustomCacheNew { static CustomCacheNew
() // { Task.Run(() => // { while (true) //死循环来判断 { try { //Thread.Sleep(60 *
1000 * 10); //十分钟后开始清理缓存 List<string> delKeyList = new List<string>(); foreach (
var key in CustomCacheDictionary.Keys) { DataModel model = CustomCacheDictionary
[key]; if (model.Deadline < DateTime.Now && model.ObsloteType != ObsloteType.
Never) // { delKeyList.Add(key); } } delKeyList.ForEach(key => Remove(key)); }
catch (Exception ex) { Console.WriteLine(ex.Message); throw; } } }); } ///
<summary> /// static:不会被Gc回收; /// Private:不让外部访问他 /// /// 线程安全字典 /// </summary>
private static ConcurrentDictionary<string, DataModel> CustomCacheDictionary =
new ConcurrentDictionary<string, DataModel>(); /// <summary> /// 默认你是不过期 ///
</summary> /// <param name="key"></param> /// <param name="value"></param>
public static void Add(string key, object value) { CustomCacheDictionary.TryAdd(
key, new DataModel() { Value = value, ObsloteType = ObsloteType.Never }); } ///
<summary> /// 绝对过期 /// </summary> /// <param name="key"></param> /// <param
name="value"></param> /// <param name="timeOutSecond"></param> public static
void Add(string key, object value, int timeOutSecond) //3000 {
CustomCacheDictionary.TryAdd(key, new DataModel() { Value = value, ObsloteType =
ObsloteType.Absolutely, Deadline = DateTime.Now.AddSeconds(timeOutSecond) }); ;
} public static void Add(string key, object value, TimeSpan durtion) {
CustomCacheDictionary.TryAdd(key, new DataModel() { Value = value, ObsloteType =
ObsloteType.Relative, Deadline = DateTime.Now.Add(durtion), Duraton = durtion }
); ; ; } //清楚所有缓存,殃及池鱼! public static void RemoveAll() { CustomCacheDictionary.
Clear();//字典中的所有内容全部被清理到 } public static void Remove(string key) { DataModel
data= null; CustomCacheDictionary.TryRemove(key, out data); } public static T
Get<T>(string key) { return (T)(CustomCacheDictionary[key]).Value; } ///
<summary> /// 判断是否存在 /// </summary> /// <param name="key"></param> ///
<returns></returns> public static bool Exists(string key) { if (
CustomCacheDictionary.ContainsKey(key)) { DataModel model =
CustomCacheDictionary[key]; if (model.ObsloteType == ObsloteType.Never) { return
true; } else if (model.Deadline < DateTime.Now) // { DataModel data = null;
CustomCacheDictionary.TryRemove(key, out data); return false; } else { if (model
.ObsloteType == ObsloteType.Relative) { model.Deadline = DateTime.Now.Add(model.
Duraton); } return true; } } else { return false; } } public static T GetT<T>(
string key, Func<T> func) { T t = default(T); if (!Exists(key)) { t = func.
Invoke(); Add(key, t); } else { t = Get<T>(key); } return t; } } internal class
DataModel { public object Value { get; set; } public ObsloteType ObsloteType {
get; set; } public DateTime Deadline { get; set; } public TimeSpan Duraton { get
; set; } } public enum ObsloteType { Never, Absolutely, Relative } /// <summary>
/// 解决性能问题 /// </summary> public class CustomCacheNewproblem { private static
List<Dictionary<string, DataModel>> dicCacheList = new List<Dictionary<string,
DataModel>>(); private static List<object> lockList = new List<object>(); public
static int CupNum = 0; static CustomCacheNewproblem() { CupNum = 3;//模拟获取获取CPU片数
//动态生成字典 for (int i = 0; i < CupNum; i++) { dicCacheList.Add(new Dictionary<
string, DataModel>()); //CPU 有几片 就来几个字典 lockList.Add(new object());//没个字典对应一个锁 }
Task.Run(() => // { while (true) //死循环来判断 { try { for (int i = 0; i < CupNum; i
++) { lock (lockList[i]) { //Thread.Sleep(60 * 1000 * 10); //十分钟后开始清理缓存 List<
string> delKeyList = new List<string>(); foreach (var key in dicCacheList[i].
Keys) { DataModel model = dicCacheList[i][key]; if (model.Deadline < DateTime.
Now&& model.ObsloteType != ObsloteType.Never) // { delKeyList.Add(key); } }
delKeyList.ForEach(key => dicCacheList[i].Remove(key)); } } } catch (Exception
ex) { Console.WriteLine(ex.Message); throw; } } }); } /// <summary> /// 默认你是不过期
/// </summary> /// <param name="key"></param> /// <param name="value"></param>
public static void Add(string key, object value) { int hash = key.GetHashCode()
* (-1); //只要字符串变,hash值不变! int index = hash % CupNum; lock (lockList[index])
dicCacheList[index].Add(key, new DataModel() { Value = value, ObsloteType =
ObsloteType.Never }); } /// <summary> /// 绝对过期 /// </summary> /// <param
name="key"></param> /// <param name="value"></param> /// <param
name="timeOutSecond"></param> public static void Add(string key, object value,
int timeOutSecond) //3000 { int hash = key.GetHashCode() * (-1);
//只要字符串变,hash值不变! int index = hash % CupNum; lock (lockList[index]) dicCacheList
[index].Add(key, new DataModel() { Value = value, ObsloteType = ObsloteType.
Absolutely, Deadline = DateTime.Now.AddSeconds(timeOutSecond) }); ; } public
static void Add(string key, object value, TimeSpan durtion) { int hash = key.
GetHashCode() * (-1); //只要字符串变,hash值不变! int index = hash % CupNum; lock (
lockList[index]) dicCacheList[index].Add(key, new DataModel() { Value = value,
ObsloteType= ObsloteType.Relative, Deadline = DateTime.Now.Add(durtion), Duraton
= durtion }); ; ; } //清楚所有缓存,殃及池鱼! public static void RemoveAll() { for (int i =
0; i < CupNum; i++) { dicCacheList[i].Clear(); } } public static void Remove(
string key) { int hash = key.GetHashCode() * (-1); //只要字符串变,hash值不变! int index =
hash% CupNum; if (dicCacheList[index].ContainsKey(key)) { dicCacheList[index].
Remove(key); } } public static T Get<T>(string key) { int hash = key.GetHashCode
() * (-1); //只要字符串变,hash值不变! int index = hash % CupNum; return (T)(dicCacheList[
index][key]).Value; } /// <summary> /// 判断是否存在 /// </summary> /// <param
name="key"></param> /// <returns></returns> public static bool Exists(string key
) { int hash = key.GetHashCode() * (-1); //只要字符串变,hash值不变! int index = hash %
CupNum; if (dicCacheList[index].ContainsKey(key)) { DataModel model =
dicCacheList[index][key]; if (model.ObsloteType == ObsloteType.Never) { return
true; } else if (model.Deadline < DateTime.Now) // { dicCacheList[index].Remove(
key); return false; } else { if (model.ObsloteType == ObsloteType.Relative) {
model.Deadline = DateTime.Now.Add(model.Duraton); } return true; } } else {
return false; } } public static T GetT<T>(string key, Func<T> func) { T t =
default(T); if (!Exists(key)) { t = func.Invoke(); Add(key, t); } else { t = Get
<T>(key); } return t; } }

技术
©2020 ioDraw All rights reserved
在上海做什么赚钱快?这10个你可以试一试!PHP 先返回结果到前端,PHP代码继续执行后续的任务centos7部署springboot jar包 疫情过后 学哪个编程有前景安卓开发—根据顾客预算显示食物信息苹果iPhone 12全系售价泄露:官方最高售价近1万元log4j打印异常堆栈信息的方法PTA快速排序日经:索尼和铠侠正积极申请华为供货许可一个学生关于鸿蒙系统的一些看法