HuanMengProject/src/0-core/HuanMeng.MiaoYu.Code/Cache/MiaoYuCache.cs

using AutoMapper;

using HuanMeng.MiaoYu.Code.Cache.Contract;
using HuanMeng.MiaoYu.Code.Cache.Special;
using HuanMeng.MiaoYu.Code.DataAccess;
using HuanMeng.MiaoYu.Model.Dto.Character;

using System.Linq.Expressions;

namespace HuanMeng.MiaoYu.Code.Cache
{
    /// <summary>
    /// 缓存类
    /// </summary>
    /// <param name="dao"></param>
    public partial class MiaoYuCache(CacheBase cacheBase)
    {
        #region 角色缓存表

        /// <summary>
        /// 对话角色缓存表
        /// </summary>
        public CommonDataEntityCache<T_Character>? Character { get; set; }
        /// <summary>
        /// 角色数据表
        /// </summary>
        public List<T_Character> CharacterInfoList
        {
            get
            {
                if (Character == null)
                {
                    //Character = new MiaoYuDataEntityCache<T_Character>(dao, MiaoYuCacheExtend.CharacterLock);
                    Character = MiaoYuCacheExtend.GetMiaoYuDataEntityCache<T_Character>(cacheBase);
                }
                return Character.DataList ?? new List<T_Character>();
            }
        }

        #endregion

        #region 模型缓存表


        /// <summary>
        /// 模型缓存表
        /// </summary>
        public CommonDataEntityCache<T_Model_Config>? ModelConfig { get; set; }
        /// <summary>
        /// 模型
        /// </summary>
        public List<T_Model_Config> ModelConfigList
        {
            get
            {
                if (ModelConfig == null)
                {
                    ModelConfig = MiaoYuCacheExtend.GetMiaoYuDataEntityCache<T_Model_Config>(cacheBase);
                }
                return ModelConfig.DataList ?? new List<T_Model_Config>();
            }
        }

        #endregion

        #region 角色信息
        /// <summary>
        /// 角色缓存表
        /// </summary>
        public CommonDataEntityCache<CharacterCache>? CharacterCache { get; set; }
        /// <summary>
        /// 角色
        /// </summary>
        public List<CharacterCache> CharacterList
        {
            get
            {
                if (CharacterCache == null)
                {
                    CharacterCache = MiaoYuCacheExtend.GetMiaoYuDataEntityCache<CharacterCache>(cacheBase);
                    //CharacterCache = new CharacterEntityCache(cacheBase);
                }
                return CharacterCache.DataList ?? new List<CharacterCache>();
            }
        }
        #endregion

        #region 图片缓存表


        /// <summary>
        /// 图片缓存表
        /// </summary>
        public CommonDataEntityCache<T_Image_Config>? ImageConfigCache { get; set; }
        /// <summary>
        /// 图片
        /// </summary>
        public List<T_Image_Config> ImageConfigList
        {
            get
            {
                if (ImageConfigCache == null)
                {
                    //ImageConfigCache = new MiaoYuDataEntityCache<T_Image_Config>(dao, MiaoYuCacheExtend.ImageConfigLock);
                    ImageConfigCache = MiaoYuCacheExtend.GetMiaoYuDataEntityCache<T_Image_Config>(cacheBase);
                }
                return ImageConfigCache.DataList ?? new List<T_Image_Config>();
            }
        }

        #endregion


        #region 角色类型缓存表


        /// <summary>
        /// 角色类型缓存表
        /// </summary>
        public CommonDataEntityCache<T_Character_Type>? CharacterTypeCache { get; set; }
        /// <summary>
        /// 角色类型
        /// </summary>
        public List<T_Character_Type> CharacterTypeList
        {
            get
            {
                if (CharacterTypeCache == null)
                {
                    //CharacterTypeCache = new MiaoYuDataEntityCache<T_Character_Type>(dao, MiaoYuCacheExtend.CharacterTypeLock);
                    CharacterTypeCache = MiaoYuCacheExtend.GetMiaoYuDataEntityCache<T_Character_Type>(cacheBase);
                }
                return CharacterTypeCache.DataList ?? new List<T_Character_Type>();
            }
        }

        #endregion

        #region 角色类型缓存表


        /// <summary>
        /// 类型中的角色缓存表
        /// </summary>
        public CommonDataEntityCache<T_Character_Type_Intimacy>? CharacterTypeIntimacyCache { get; set; }
        /// <summary>
        /// 类型中的角色
        /// </summary>
        public List<T_Character_Type_Intimacy> CharacterTypeIntimacyList
        {
            get
            {
                if (CharacterTypeIntimacyCache == null)
                {
                    //CharacterTypeIntimacyCache = new MiaoYuDataEntityCache<T_Character_Type_Intimacy>(dao, MiaoYuCacheExtend.CharacterTypeIntimacyLock);
                    CharacterTypeIntimacyCache = MiaoYuCacheExtend.GetMiaoYuDataEntityCache<T_Character_Type_Intimacy>(cacheBase);
                }
                return CharacterTypeIntimacyCache.DataList ?? new List<T_Character_Type_Intimacy>();
            }
        }

        #endregion
    }
    /// <summary>
    /// 缓存扩展类
    /// </summary>

    public static class MiaoYuCacheExtend
    {
        #region 缓存锁
        /// <summary>
        /// 对话角色缓存表
        /// </summary>
        public static object CharacterLock = new object();

        /// <summary>
        /// 模型缓存表
        /// </summary>
        public static object ModelConfigLock = new object();

        /// <summary>
        /// 图片缓存表
        /// </summary>
        public static object ImageConfigLock = new object();
        /// <summary>
        ///角色类型缓存表
        /// </summary>
        public static object CharacterTypeLock = new object();

        /// <summary>
        /// 类型中的角色缓存表
        /// </summary>
        public static object CharacterTypeIntimacyLock = new object();

        /// <summary>
        /// 缓存锁对象
        /// </summary>
        public static Dictionary<Type, object> CacheLockList { get; set; } = new Dictionary<Type, object>
        {
            { typeof(T_Character), CharacterLock },
            { typeof(T_Model_Config), ModelConfigLock },
            { typeof(T_Image_Config), ImageConfigLock },
            { typeof(T_Character_Type), CharacterTypeLock },
            { typeof(T_Character_Type_Intimacy), CharacterTypeIntimacyLock },
        };
        /// <summary>
        ///  特殊的缓存锁对象
        /// </summary>
        public static Dictionary<Type, object> SpecialCacheLockList { get; set; } = new Dictionary<Type, object>
        {
            { typeof(CharacterCache), CharacterLock },
        };
        #endregion

        #region 缓存扩展
        /// <summary>
        /// 获取对应的缓存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="cacheBase"></param>
        /// <returns></returns>
        public static CommonDataEntityCache<T> GetMiaoYuDataEntityCache<T>(CacheBase cacheBase) where T : class
        {
            object cacheLock;
            var typeo = typeof(T);
            if (SpecialCacheLockList.TryGetValue(typeo, out cacheLock))
            {
                var o = new CharacterEntityCache(cacheBase, cacheLock) as CommonDataEntityCache<T>;
                return o;
            }
            if (!CacheLockList.TryGetValue(typeo, out cacheLock))
            {
                Console.WriteLine("没有找到锁对象==>" + typeo.Name);
                // 创建一个新的锁对象，并添加到 CacheLockList 中
                cacheLock = new object();
                CacheLockList[typeo] = cacheLock;
            }
            return new MiaoYuDataEntityCache<T>(cacheBase, cacheLock);
        }
        /// <summary>
        /// 获取缓存数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="cacheBase"></param>
        /// <returns></returns>
        public static List<T> GetMiaoYuDataEntityCacheList<T>(CacheBase cacheBase) where T : class
        {
            var cache = GetMiaoYuDataEntityCache<T>(cacheBase);
            return cache?.DataList ?? new List<T>();
        }

        /// <summary>
        /// 清除全部缓存
        /// </summary>
        /// <param name="dao"></param>
        public static void ClareMiaoYuDataEntityCache(CacheBase cacheBase)
        {
            foreach (var item in CacheLockList)
            {
                var t = item.Key;
                Type cacheType = typeof(MiaoYuDataEntityCache<>).MakeGenericType(t);
                var shujuduixiang = Activator.CreateInstance(cacheType, cacheBase, item.Value, 36000);
                var x = shujuduixiang as ICacheClearData;
                if (x != null)
                {
                    x.ClearData();
                }
            }
            var obj = SpecialCacheLockList[typeof(CharacterCache)];
            CharacterEntityCache characterEntityCache = new CharacterEntityCache(cacheBase, obj);
            characterEntityCache.ClearData();
        }

        /// <summary>
        /// 刷新部缓存
        /// </summary>
        /// <param name="dao"></param>
        public static void ReloadMiaoYuDataEntityCache(CacheBase cacheBase)
        {
            foreach (var item in CacheLockList)
            {
                var t = item.Key;
                Type cacheType = typeof(MiaoYuDataEntityCache<>).MakeGenericType(t);
                var shujuduixiang = Activator.CreateInstance(cacheType, cacheBase, item.Value, 36000);
                var x = shujuduixiang as ICacheReloadData;
                if (x != null)
                {
                    x.ReloadData();
                }
            }
            var obj = SpecialCacheLockList[typeof(CharacterCache)];
            CharacterEntityCache characterEntityCache = new CharacterEntityCache(cacheBase, obj);
            characterEntityCache.ReloadData();
        }
        #endregion

        #region 图片扩展
        /// <summary>
        /// 获取图片
        /// </summary>
        /// <param name="imageId"></param>
        /// <param name="miaoYuCache"></param>
        /// <returns></returns>
        public static string GetImageUrl(this int imageId, MiaoYuCache miaoYuCache)
        {
            if (imageId == 0 || miaoYuCache == null)
            {
                return "";
            }
            var _m = miaoYuCache.ImageConfigList.FirstOrDefault(it => it.ImageId == imageId);
            if (_m != null)
            {
                return _m.Url;
            }
            return "";
        }
        /// <summary>
        /// 获取图片
        /// </summary>
        /// <param name="imageId"></param>
        /// <param name="dao"></param>
        /// <returns></returns>
        public static string GetImageUrl(this int imageId, CacheBase cacheBase)
        {
            if (imageId == 0 || cacheBase == null)
            {
                return "";
            }
            MiaoYuCache miaoYuCache = new MiaoYuCache(cacheBase);

            return GetImageUrl(imageId, miaoYuCache);
        }
        #endregion
    }


}