/// <summary> /// Remove cache data by type /// </summary> /// <param name="type">Data type</param> protected virtual void RemoveCacheDataByType(Type type) { if (type == null) { return; } var cacheObject = new CacheObject() { ObjectName = type.Name }; CacheKey mateKey = new CacheKey(cacheObject); do { var getKeysCommand = new GetKeysOptions() { CacheObject = cacheObject, Query = new KeyQuery() { MateKey = mateKey.GetActualKey(), Type = KeyMatchPattern.StartWith, Page = 1, PageSize = 10000 } }; var keyResponses = CacheManager.Keys.GetKeysAsync(getKeysCommand).Result?.Responses; if (keyResponses.IsNullOrEmpty()) { break; } List <CacheKey> cacheKeys = new List <CacheKey>(); foreach (var response in keyResponses) { if (response?.Keys.IsNullOrEmpty() ?? true) { continue; } foreach (var key in response.Keys) { cacheKeys.Add(key); } } if (cacheKeys.IsNullOrEmpty()) { break; } var keyDeleteCommand = new DeleteOptions() { CacheObject = cacheObject, Keys = cacheKeys }; var result = CacheManager.Keys.Delete(keyDeleteCommand); if (result != null && !result.Responses.IsNullOrEmpty()) { foreach (var response in result.Responses) { if (!string.IsNullOrWhiteSpace(response?.Message)) { LogManager.LogInformation <DefaultDataCachePolicy>(response.Message); } } } } while (true); }
/// <summary> /// Get cache datas by type /// </summary> /// <typeparam name="T">Data type</typeparam> /// <param name="size">Return data size</param> /// <returns></returns> protected virtual List <T> GetCacheDatasByType <T>(IQuery query, int size) { var type = typeof(T); var needSort = query != null && !query.Orders.IsNullOrEmpty(); if (needSort) { return(new List <T>(0)); } #region get cache keys var typeName = type.Name; var primaryKeys = EntityManager.GetPrimaryKeys(type); var firstPrimaryKey = primaryKeys?.FirstOrDefault(); if (string.IsNullOrWhiteSpace(firstPrimaryKey)) { return(new List <T>(0)); } var cacheObject = new CacheObject() { ObjectName = typeName }; CacheKey mateKey = new CacheKey(cacheObject); mateKey.AddName(firstPrimaryKey); var getKeysCommand = new GetKeysOptions() { CacheObject = cacheObject, Query = new KeyQuery() { MateKey = mateKey.GetActualKey(), Type = KeyMatchPattern.StartWith, Page = 1, PageSize = size > 0 ? size : int.MaxValue } }; var keyResponses = CacheManager.Keys.GetKeysAsync(getKeysCommand).Result?.Responses; if (keyResponses.IsNullOrEmpty()) { return(new List <T>(0)); } List <CacheKey> dataKeys = new List <CacheKey>(); foreach (var response in keyResponses) { if (response?.Keys.IsNullOrEmpty() ?? true) { continue; } bool fullData = false; foreach (var key in response.Keys) { if (size > 0 && dataKeys.Count >= size) { fullData = true; break; } dataKeys.Add(key); } if (fullData) { break; } } if (dataKeys.IsNullOrEmpty()) { return(new List <T>(0)); } #endregion #region get cache data return(CacheManager.GetDataList <T>(dataKeys, cacheObject)); #endregion }
/// <summary> /// Add datas /// </summary> /// <typeparam name="T">Data type</typeparam> /// <param name="query">Query condition</param> /// <param name="datas">Datas</param> protected virtual void AddCacheData <T>(QueryDataCallbackContext <T> queryDataCallbackContext) where T : BaseEntity <T>, new() { if (queryDataCallbackContext == null) { return; } #region Add cache data var datas = queryDataCallbackContext.Datas; List <CacheKey> dataPrimaryKeys = null; List <CacheKey> dataOtherKeys = null; List <CacheEntry> storeItems = new List <CacheEntry>(); Type entityType = typeof(T); string objectName = entityType.Name; var cacheObject = new CacheObject() { ObjectName = objectName }; int dataCount = 0; if (!datas.IsNullOrEmpty()) { dataPrimaryKeys = new List <CacheKey>(); dataOtherKeys = new List <CacheKey>(); var entityConfiguration = EntityManager.GetEntityConfiguration(entityType); if (entityConfiguration == null) { LogManager.LogError <DefaultDataCachePolicy>($"Entity :{entityType.FullName} configuration is null"); return; } //primary keys var primaryKeys = entityConfiguration.PrimaryKeys; if (primaryKeys.IsNullOrEmpty()) { LogManager.LogError <DefaultDataCachePolicy>($"Data type:{entityType.FullName} no primary key,unable to set cache data"); return; } //cache keys var cacheKeys = entityConfiguration.CacheKeys ?? new List <string>(0); cacheKeys = cacheKeys.Except(primaryKeys).ToList(); //cache prefix keys var cachePrefixKeys = entityConfiguration.CachePrefixKeys ?? new List <string>(0); foreach (var data in datas) { if (data == null) { continue; } dataCount++; bool keyValueSuccess = true; //expiration TimeSpan? dataExpirationValue = DataCacheManager.Configuration.GetExpiration(entityType); DateTimeOffset?dataExpirationTime = null; if (dataExpirationValue != null) { dataExpirationTime = DateTimeOffset.Now.Add(dataExpirationValue.Value).AddSeconds(randomSecondPrivider.TakeNextValues(1).FirstOrDefault()); } CacheExpiration dataExpiration = new CacheExpiration() { SlidingExpiration = false, AbsoluteExpiration = dataExpirationTime }; //prefix cache keys var dataPrefixKey = new CacheKey(); if (!cachePrefixKeys.IsNullOrEmpty()) { foreach (var preKey in cachePrefixKeys) { var preKeyVal = data.GetValue(preKey)?.ToString() ?? string.Empty; if (string.IsNullOrWhiteSpace(preKeyVal)) { LogManager.LogError <DefaultDataCachePolicy>($"Data type :{entityType.FullName},Identity value:{data.GetIdentityValue()},Cache prefix key:{preKey},value is null or empty,unable to set cache data"); keyValueSuccess = false; break; } dataPrefixKey.AddName(preKey, preKeyVal); } if (!keyValueSuccess) { continue; } } //primary data cache keys var dataCacheKey = new CacheKey(cacheObject, dataPrefixKey); foreach (string pk in primaryKeys) { var pkValue = data.GetValue(pk)?.ToString() ?? string.Empty; if (string.IsNullOrWhiteSpace(pkValue)) { LogManager.LogError <DefaultDataCachePolicy>($"Data type :{entityType.FullName},Identity value:{data.GetIdentityValue()},Primary key:{pk},value is null or empty,unable to set cache data"); keyValueSuccess = false; break; } dataCacheKey.AddName(pk, pkValue); } if (!keyValueSuccess) { continue; } string primaryFullCacheKey = dataCacheKey.GetActualKey(); if (primaryFullCacheKey.IsNullOrEmpty()) { continue; } dataPrimaryKeys.Add(primaryFullCacheKey); storeItems.Add(new CacheEntry() { Key = primaryFullCacheKey, Value = JsonSerializeHelper.ObjectToJson(data), Expiration = dataExpiration }); if (!cacheKeys.IsNullOrEmpty()) { foreach (string key in cacheKeys) { var otherCacheKey = new CacheKey(cacheObject, dataPrefixKey); var cacheKeyValue = data.GetValue(key)?.ToString() ?? string.Empty; if (string.IsNullOrWhiteSpace(cacheKeyValue)) { LogManager.LogError <DefaultDataCachePolicy>($"Data type :{entityType.FullName},Identity value:{data.GetIdentityValue()},Cache key:{key},value is null or empty,unable to set cache data"); keyValueSuccess = false; break; } otherCacheKey.AddName(key, cacheKeyValue?.ToString() ?? string.Empty); dataOtherKeys.Add(otherCacheKey); storeItems.Add(new CacheEntry() { Key = otherCacheKey.GetActualKey(), Value = primaryFullCacheKey, Expiration = dataExpiration }); } if (!keyValueSuccess) { continue; } } } } #endregion #region Null data int querySize = queryDataCallbackContext.Query?.QuerySize ?? 0; if (DataCacheManager.Configuration.EnableCacheNullData && (querySize < 1 || dataCount < querySize)) { IEnumerable <CacheKey> queryPrimaryKeys = queryDataCallbackContext.PrimaryCacheKeys; IEnumerable <CacheKey> queryOtherKeys = queryDataCallbackContext.OtherCacheKeys; string nullDataValue = JsonSerializeHelper.ObjectToJson <T>(null); TimeSpan? nullDataExpirationValue = DataCacheManager.Configuration.GetNullDataExpiration(entityType); DateTimeOffset?nullDataExpiration = null; if (nullDataExpirationValue != null) { nullDataExpiration = DateTimeOffset.Now.Add(nullDataExpirationValue.Value); } CacheExpiration nullDataExp = new CacheExpiration() { SlidingExpiration = false, AbsoluteExpiration = nullDataExpiration }; if (!queryPrimaryKeys.IsNullOrEmpty()) { if (!dataPrimaryKeys.IsNullOrEmpty()) { queryPrimaryKeys = queryPrimaryKeys.Except(dataPrimaryKeys); } foreach (var primaryKey in queryPrimaryKeys) { storeItems.Add(new CacheEntry() { Key = primaryKey.GetActualKey(), Value = nullDataValue, Expiration = nullDataExp }); } } if (!queryOtherKeys.IsNullOrEmpty()) { if (!dataOtherKeys.IsNullOrEmpty()) { queryOtherKeys = queryOtherKeys.Except(dataOtherKeys); } if (!queryOtherKeys.IsNullOrEmpty()) { storeItems.Add(new CacheEntry() { Key = DataCacheManager.Configuration.NullDataCacheKey, Value = nullDataValue, Expiration = nullDataExp }); foreach (var otherKey in queryOtherKeys) { storeItems.Add(new CacheEntry() { Key = otherKey, Value = DataCacheManager.Configuration.NullDataCacheKey, Expiration = nullDataExp }); } } } } #endregion StringSetOptions option = new StringSetOptions() { CacheObject = cacheObject, Items = storeItems, CommandFlags = CacheCommandFlags.FireAndForget }; var cacheResult = CacheManager.String.Set(option); if (cacheResult != null && !cacheResult.Responses.IsNullOrEmpty()) { foreach (var response in cacheResult.Responses) { if (!string.IsNullOrWhiteSpace(response?.Message)) { LogManager.LogInformation <DefaultDataCachePolicy>(response.Message); } } } }