支持高并发高性能 通用缓存容器

说明：不是很理解并发和缓存逻辑的朋友，请务必自己敲一下代码，好好理解一下，，老司机不用多说了，，拿来就可以用。

————————————————————— 华丽的分割线———————————————————————————

public static class CustomCache
{

private static List<ConcurrentDictionary<string, DataModel>> cacheContainer = null;

private static readonly int cpuCount = Environment.ProcessorCount;//获取CPU个数

static CustomCache()
{
cacheContainer = new List<ConcurrentDictionary<string, DataModel>>();
for (int i = 0; i < cpuCount; i++)
{
cacheContainer.Add(new ConcurrentDictionary<string, DataModel>());
}
AutoClaerCache(900000);//每隔15分钟自动清理
}

/// <summary>
/// 自动清理缓存
/// </summary>
/// <param name="intervalTime">间隔时间 毫秒为单位</param>
private static void AutoClaerCache(int intervalTime)
{
Task.Factory.StartNew(() =>
{
while (true)
{
Thread.Sleep(intervalTime);
for (int i = 0; i < cacheContainer.Count; i++)
{
var cache = cacheContainer[i].Where(w => w.Value.LifeCycleType == LifeCycle.Temp);
foreach (var item in cache)
{
if (DateTime.Now > item.Value.ExpirationTime)
{
cacheContainer[i].TryRemove(item.Key, out DataModel dataModel);
}
}
}
}
});
}

/// <summary>
/// 添加缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="keyValue">键值</param>
public static void Add(string key, object keyValue)
{
if (ExistsCacheData(key, out int i))
{
cacheContainer[i][key] = new DataModel { LifeCycleType = LifeCycle.Lasting, CacheData = keyValue };
}
else
{
cacheContainer[Math.Abs(key.GetHashCode() % cpuCount)].TryAdd(key, new DataModel { LifeCycleType = LifeCycle.Lasting, CacheData = keyValue });
}
}

/// <summary>
/// 添加缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="keyValue">键值</param>
/// <param name="timeOut">超时 分钟为单位</param>
public static void Add(string key, object keyValue, int timeOut)
{
if (ExistsCacheData(key, out int i))
{
cacheContainer[i][key] = new DataModel { LifeCycleType = LifeCycle.Temp, ExpirationTime = DateTime.Now.AddMinutes(timeOut), CacheData = keyValue };
}
else
{
cacheContainer[Math.Abs(key.GetHashCode() % cpuCount)].TryAdd(key, new DataModel { LifeCycleType = LifeCycle.Temp, ExpirationTime = DateTime.Now.AddMinutes(timeOut), CacheData = keyValue });
}
}

/// <summary>
/// 删除缓存
/// </summary>
/// <param name="key">键</param>
public static void Remove(string key)
{
if (ExistsCacheData(key, out int i))
{
cacheContainer[i].TryRemove(key, out DataModel dataModel);
}
}

/// <summary>
/// 获取缓存数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key">键</param>
/// <param name="func">委托</param>
/// <param name="timeOut">超时时间 分钟为单位 默认为0 则 持久</param>
/// <returns></returns>
public static T GetCacheData<T>(string key, Func<T> func, int timeOut = 10)
{
var data = default(object);
if (ExistsCacheData(key, out int i))
{
var temp = cacheContainer[i][key];
if (temp.LifeCycleType == LifeCycle.Temp && DateTime.Now > temp.ExpirationTime)
{
cacheContainer[i].TryRemove(key, out DataModel delModel);
temp.CacheData = null;
}
data = temp.CacheData.GetType() == typeof(T) ? temp.CacheData : null;//解决存在键值类型不一致的BUG
}
if (data == null)
{
var result = func.Invoke();
if (timeOut > 0)
{
Add(key, data, timeOut);
}
else
{
Add(key, data);
}
return result;
}
else
{
return (T)data;
}
}

/// <summary>
/// 检查缓存数据
/// </summary>
/// <param name="key">键</param>
/// <param name="containerIndex">容器索引</param>
/// <returns></returns>
public static bool ExistsCacheData(string key, out int containerIndex)
{
for (int i = 0; i < cacheContainer.Count; i++)
{
if (cacheContainer[i].ContainsKey(key))
{
containerIndex = i;
return true;
}
}
containerIndex = -1;
return false;
}
}

internal class DataModel
{
/// <summary>
/// 生命周期类型
/// </summary>
public LifeCycle LifeCycleType { get; set; }

/// <summary>
/// 到期时间
/// </summary>
public DateTime ExpirationTime { get; set; }

/// <summary>
/// 缓存数据
/// </summary>
public object CacheData { get; set; }
}

/// <summary>
/// 生命周期枚举
/// </summary>
internal enum LifeCycle
{
Lasting = 0,//持久
Temp = 1//临时
}

————————————————————— 华丽的分割线———————————————————————————