/// <summary>
/// 按类型获取缓存,只能在继承类实现,只能同时有一个类型
/// 不建议直接调用,请调用AllCache或重写调用
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
protected Dictionary <int, TModel> GetCache(LambdaQuery <TModel> query)
{
Type type = typeof(TModel);
int expMinute = query.ExpireMinute;
if (expMinute == 0)
{
expMinute = 5;
}
string dataCacheKey;
var list = new Dictionary <int, TModel>();
if (!TypeCache.ModelKeyCache.ContainsKey(type))
{
var helper = GetDbHelper(GetType());//避开事务控制,使用新的连接
var list2 = helper.QueryList <TModel>(query, expMinute, out dataCacheKey);
list = MemoryDataCache.ConvertToDictionary <TModel>(list2);
lock (lockObj)
{
if (!TypeCache.ModelKeyCache.ContainsKey(type))
{
TypeCache.ModelKeyCache.Add(type, dataCacheKey);
}
}
}
else
{
dataCacheKey = TypeCache.ModelKeyCache[type];
list = MemoryDataCache.GetCacheItem <TModel>(dataCacheKey);
}
return(list);
}
/// <summary>
/// 批量插入,并指定是否保持自增主键
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="details"></param>
/// <param name="keepIdentity"></param>
public void BatchInsert <TItem>(List <TItem> details, bool keepIdentity = false) where TItem : IModel, new()
{
CheckTableCreated <TItem>();
if (details.Count == 0)
{
return;
}
foreach (TItem item in details)
{
CheckData(item);
}
_DBAdapter.BatchInsert(helper, details, keepIdentity);
//var type = typeof(TItem);
//if (TypeCache.ModelKeyCache.ContainsKey(type))
//{
// string key = TypeCache.ModelKeyCache[type];
// foreach (var item in details)
// {
// MemoryDataCache.UpdateCacheItem(key, item);
// }
//}
var updateModel = MemoryDataCache.GetCacheTypeKey(typeof(TItem));
foreach (var item in details)
{
foreach (var key in updateModel)
{
MemoryDataCache.UpdateCacheItem(key, item, null);
}
}
}
/// <summary>
/// 使用完整的LamadaQuery查询
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="query"></param>
/// <param name="cacheTime"></param>
/// <param name="cacheKey">过期时间,分</param>
/// <param name="compileSp">是否编译成储过程</param>
/// <returns></returns>
public List <TItem> QueryList <TItem>(LambdaQuery <TItem> query, int cacheTime, out string cacheKey, bool compileSp = false) where TItem : IModel, new()
{
CheckTableCreated <TItem>();
if (query.PageSize > 0)//按分页
{
cacheKey = "";
int count;
return(AutoSpPage(query, out count));
}
string sql = "";
bool setConstraintObj = true;
cacheKey = "";
//foreach (var n in query.QueryParames)
//{
// AddParam(n.Key, n.Value);
//}
query.FillParames(this);
sql = query.GetQuery();
sql = _DBAdapter.SqlFormat(sql);
//DataTable dt;
System.Data.Common.DbDataReader reader;
List <TItem> list;
if (cacheTime <= 0)
{
if (!compileSp)
{
if (query.QueryTop > 0)
{
helper.AutoFormatWithNolock = false;
}
reader = helper.ExecDataReader(sql);
}
else//生成储过程
{
string sp = CompileSqlToSp(_DBAdapter.TemplateSp, sql);
reader = helper.RunDataReader(sql);
}
list = ObjectConvert.DataReaderToList <TItem>(reader, setConstraintObj, query.FieldMapping);
}
else
{
list = MemoryDataCache.GetCacheList <TItem>(sql, cacheTime, helper, out cacheKey).Values.ToList();
}
ClearParame();
query.RowCount = list.Count;
SetOriginClone(list);
return(list);
}
/// <summary>
/// 更新缓存中的一项
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="newObj"></param>
/// <param name="c"></param>
internal void UpdateCacheItem <TItem>(TItem newObj, ParameCollection c) where TItem : IModel
{
var updateModel = MemoryDataCache.GetCacheTypeKey(typeof(TItem));
foreach (var key in updateModel)
{
MemoryDataCache.UpdateCacheItem(key, newObj, c);
}
NotifyCacheServer(newObj);
//Type type = typeof(TItem);
//if (TypeCache.ModelKeyCache.ContainsKey(type))
//{
// string key = TypeCache.ModelKeyCache[type];
// MemoryDataCache.UpdateCacheItem(key,newObj);
//}
}
/// <summary>
/// 查询命令处理
/// </summary>
/// <param name="command"></param>
/// <returns></returns>
public CacheServer.ResultData DeaCacheCommand(CacheServer.Command command)
{
if (command.CommandType == CacheServer.CommandType.查询)
{
var expression = LambdaQuery.CRLQueryExpression.FromJson(command.Data);
return(QueryFromAllCache(expression));
}
else
{
//更新缓存
var item = (TModel)CoreHelper.SerializeHelper.SerializerFromJSON(command.Data, typeof(TModel), Encoding.UTF8);
var updateModel = MemoryDataCache.GetCacheTypeKey(typeof(TModel));
foreach (var key in updateModel)
{
MemoryDataCache.UpdateCacheItem(key, item, null);
}
return(new CacheServer.ResultData());
}
}
/// <summary>
/// 按表达式更新缓存中项
/// 当前类型有缓存时才会进行查询
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="expression"></param>
void UpdateCacheItem <TItem>(Expression <Func <TItem, bool> > expression, ParameCollection c) where TItem : IModel, new()
{
//事务开启不执行查询
if (currentTranStatus == TranStatus.已开始)
{
return;
}
Type type = typeof(TItem);
var updateModel = MemoryDataCache.GetCacheTypeKey(typeof(TItem));
foreach (var key in updateModel)
{
var list = QueryList <TItem>(expression);
foreach (var item in list)
{
MemoryDataCache.UpdateCacheItem(key, item, c);
NotifyCacheServer(item);
}
}
}
/// <summary>
/// 清除所有内置缓存
/// </summary>
public static void ClearCache()
{
MemoryDataCache.Clear();
}
