예제 #1
0
파일: DefaultCache.cs 프로젝트: tynr426/ict
        /// <summary>
        /// 获得实例
        /// </summary>
        private static void GetInstance()
        {
            if (Enable && _instance == null)
            {
                lock (syncObj)
                {
                    string cacheKey = "ecf";
                    try
                    {
                        CacheServerProvider provider = CacheFactory.GetCacheServerProvider(cacheKey);
                        if (provider != null)
                        {
                            _instance = CacheFactory.GetCacheService(provider);
                        }

                        // 当前在的配置错误没有取到配置的缓存服务读取默认服务
                        if (_instance == null)
                        {
                            _instance = CacheFactory.GetDefaultService();
                        }
                    }
                    catch (Exception ex)
                    {
                        new ECFException(ex);
                    }
                }
            }
        }
예제 #2
0
파일: CacheFactory.cs 프로젝트: tynr426/ict
        /// <summary>
        /// 获取缓存服务
        /// </summary>
        /// <param name="cacheProvider">The cache provider.</param>
        /// <returns>
        /// ICacheService
        /// </returns>
        /// <remarks>
        /// <list>
        ///   <item>
        ///     <description>说明原因 added by Shaipe 2018/10/18</description>
        ///   </item>
        /// </list>
        /// </remarks>
        public static ICacheService GetCacheService(CacheServerProvider cacheProvider = null)
        {
            if (cacheService == null)
            {
                if (cacheProvider == null)
                {
                    return(null);
                }

                lock (lockHelper)
                {
                    switch (cacheProvider.Type)
                    {
                    case CacheType.Memcached:

                        break;

                    case CacheType.Redis:
                        object redis = null;
                        if (cacheProvider != null)
                        {
                            redis = GetInstance("ECF.Cache", "StackExchangeRedisService",
                                                new object[] { cacheProvider.Server, cacheProvider.Password, Utils.ToInt(cacheProvider.DBName) });
                        }
                        else
                        {
                            redis = GetInstance("ECF.Cache", "StackExchangeRedisService");
                        }

                        if (redis is ICacheService)
                        {
                            cacheService = (ICacheService)redis;
                        }
                        break;

                    default:
                        cacheService = new MemoryService();
                        break;
                    }
                }
            }

            return(cacheService);
        }
예제 #3
0
파일: CacheConfig.cs 프로젝트: tynr426/ict
        /// <summary>
        /// 配置文件解析
        /// </summary>
        /// <remarks>
        ///   <list>
        ///    <item><description>添加新方法 added by Shaipe 2018/10/23</description></item>
        ///   </list>
        /// </remarks>
        public void ConfigParser()
        {
            try
            {
                //解析基本设置
                XmlNode setting = ConfigDocument.SelectSingleNode("//settings");
                if (setting != null)
                {
                    foreach (XmlNode node in setting.ChildNodes)
                    {
                        if (node.NodeType == XmlNodeType.Element)
                        {
                            string key = XmlUtils.GetXmlNodeAttribute(node, "key");
                            string val = XmlUtils.GetXmlNodeAttribute(node, "value");
                            switch (key.ToLower())
                            {
                            case "expire":
                                Expire = Utils.ToInt(val);
                                break;

                                //    case "encrypteype":
                                //        EncryptType = val;
                                //        break;
                                //    case "secretkey":
                                //        SecretKey = val;
                                //        break;
                                //    case "ismonitor":
                                //        IsMonitor = Utils.ToBool(val);
                                //        break;
                            }
                        }
                    }
                }

                if (Caches == null)
                {
                    Caches = new CacheServerProviderCollection();
                }

                // 解析缓存配置
                XmlNode caches = ConfigDocument.SelectSingleNode("//caches");
                if (caches != null)
                {
                    Caches.Clear();
                    for (int i = 0; i < caches.ChildNodes.Count; i++)
                    {
                        XmlNode node = caches.ChildNodes[i];
                        if (node.NodeType == XmlNodeType.Element)
                        {
                            CacheServerProvider provider = new CacheServerProvider(node);
                            if (provider != null)
                            {
                                Caches.Add(provider);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                new ECFException(ex);
            }
        }