愚公搬代码

(精华)2020年8月15日 C#基础知识点 cache缓存的实现

静态字段缓存基本使用

 /// 
        ///  1 客户端缓存-CDN缓存-反向代理缓存-本地缓存
        ///  2 本地缓存原理和手写基础实现
        ///  3 缓存更新/过期/多线程测试 
        ///  4 缓存类库封装和缓存应用总结 
        /// 
        /// 
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("开发进阶/蜕变架构！");
                {
                    Console.WriteLine("***************DBHelper*****************");
                    for (int i = 0; i < 5; i++) //会重复查询数据
                    {
                        Console.WriteLine($"获取{nameof(DBHelper)} {i}次 {DateTime.Now.ToString("yyyyMMdd HHmmss.fff")}");
                        List<Program> programList = null;
                        string key = $"{nameof(Program)}_DBHelper.Query_{123}";
                        programList = CustomCache.GetT<List<Program>>(key, () =>
                        {
                            return DBHelper.Query<Program>(123);
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.Read();
        }

/// 
    ///模拟数据库查询
    /// 
    public class DBHelper
    {
        /// 
        /// 1 耗时耗资源
        /// 2 参数固定时，结果不变
        /// 
        /// 
        /// 
        /// 
        public static List<T> Query<T>(int index)
        {
            Console.WriteLine("This is {0} Query", typeof(DBHelper));
            long lResult = 0;
            
            //耗时耗资源
            for (int i = index; i < 1_000_000_000; i++)
            {
                lResult += i;
            }

            ///只要Index不变  返回值是不变的！
            List<T> tList = new List<T>();
            for (int i = 0; i < index % 3; i++)
            {
                tList.Add(default(T));
            } 
            return tList;
        }

    }

public class CustomCache
    {
        /// 
        /// 字典缓存
        /// static:不会被Gc回收；
        /// Private：不让外部访问他 
        /// 
        private static Dictionary<string, object> CustomCacheDictionary = new Dictionary<string, object>();

        public static void Add(string key, object value)
        {
            CustomCacheDictionary.Add(key, value);
        }

        public static T Get<T>(string key)
        {
            return (T)CustomCacheDictionary[key];
        }

        public static bool Exists(string key)
        {
            return CustomCacheDictionary.ContainsKey(key);
        }

        public static T GetT<T>(string key, Func<T> func)
        {
            T t = default(T);
            if (!Exists(key))
            {
                t = func.Invoke();
                Add(key, t);
            }
            else
            {
                t = Get<T>(key);
            }
            return t;
        }
    }

cache缓存封装

/// 
    /// Cache manager interface
    /// 
    public interface ICache
    {
        /// 
        /// Gets or sets the value associated with the specified key.
        /// 
        /// Type
        /// The key of the value to get.
        /// The value associated with the specified key.
        T Get<T>(string key);

        /// 
        /// Adds the specified key and object to the cache.
        /// 
        /// key
        /// Data
        /// Cache time
        void Add(string key, object data, int cacheTime = 30);

        /// 
        /// Gets a value indicating whether the value associated with the specified key is cached
        /// 
        /// key
        /// Result
        bool Contains(string key);

        /// 
        /// Removes the value with the specified key from the cache
        /// 
        /// /key
        void Remove(string key);

        /// 
        /// Clear all cache data
        /// 
        void RemoveAll();

        object this[string key] { get; set; }

        int Count { get; }
    }

/// 
    /// MemoryCacheCache
    /// 
    public class MemoryCacheCache : ICache
    {
        public MemoryCacheCache() { }

        protected ObjectCache Cache
        {
            get
            {
                return MemoryCache.Default;
            }
        }

        /// 
        /// 读取缓存
        /// 
        /// 
        /// 
        /// 
        public T Get<T>(string key)
        {
            if (Cache.Contains(key))
            {
                return (T)Cache[key];
            }
            else
            {
                return default(T);
            }
        }

        public object Get(string key)
        {
            return Cache[key];
        }

        /// 
        /// 增加缓存
        /// 
        /// 
        /// 
        /// 分钟
        public void Add(string key, object data, int cacheTime = 30)
        {
            if (data == null)
                return;

            var policy = new CacheItemPolicy();
            policy.AbsoluteExpiration = DateTime.Now + TimeSpan.FromMinutes(cacheTime);
            Cache.Add(new CacheItem(key, data), policy);
        }

        /// 
        /// 是否包含
        /// 
        /// 
        /// 
        public bool Contains(string key)
        {
            return Cache.Contains(key);
        }

        public int Count { get { return (int)(Cache.GetCount()); } }


        /// 
        /// 单个清除
        /// 
        /// /key
        public void Remove(string key)
        {
            Cache.Remove(key);
        }

        /// 
        /// 正则表达式移除
        /// 
        /// pattern
        public void RemoveByPattern(string pattern)
        {
            var regex = new Regex(pattern, RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.IgnoreCase);
            var keysToRemove = new List<String>();

            foreach (var item in Cache)
                if (regex.IsMatch(item.Key))
                    keysToRemove.Add(item.Key);

            foreach (string key in keysToRemove)
            {
                Remove(key);
            }
        }

        /// 
        /// 根据键值返回缓存数据
        /// 
        /// 
        /// 
        public object this[string key]
        {
            get { return Cache.Get(key); }
            set { Add(key, value); }
        }

        /// 
        /// 清除全部数据
        /// 
        public void RemoveAll()
        {
            foreach (var item in Cache)
                Remove(item.Key);
        }
    }

缓存管理中心

public class CacheManager
    {
        #region Identity
        private CacheManager()
        { }

        private static ICache cache = null;

        static CacheManager()
        {
            Console.WriteLine("开始缓存的初始化.....");
            //可以创建不同的cache对象
            cache = (ICache)Activator.CreateInstance(typeof(MemoryCacheCache));
            // 这里可以根据配置文件来选择
            //cache = (ICache)Activator.CreateInstance(typeof(CustomerCache));
        }
        #endregion Identity

        #region ICache
        /// 
        /// 当前缓存数据项的个数
        /// 
        public static int Count
        {
            get { return cache.Count; }
        }

        /// 
        /// 如果缓存中已存在数据项键值，则返回true
        /// 
        /// 数据项键值
        /// 数据项是否存在
        public static bool Contains(string key)
        {
            return cache.Contains(key);
        }

        /// 
        /// 获取缓存数据
        /// 
        /// 
        /// 
        public static T GetData<T>(string key)
        {
            return cache.Get<T>(key);
        }

        /// 
        /// 
        /// 
        /// 
        /// 缓存的项
        /// 没有缓存的时候获取数据的方式
        /// 单位分钟  默认30
        /// 
        public static T Get<T>(string key, Func<T> acquire, int cacheTime = 30)
        {
            if (!cache.Contains(key))
            {
                T result = acquire.Invoke();
                cache.Add(key, result, cacheTime);
            }
            return GetData<T>(key);
        }

        /// 
        /// 添加缓存数据。
        /// 如果另一个相同键值的数据已经存在，原数据项将被删除，新数据项被添加。
        /// 
        /// 缓存数据的键值
        /// 缓存的数据，可以为null值
        /// 缓存过期时间间隔(单位：分钟)
        public static void Add(string key, object value, int expiratTime = 30)
        {
            if (Contains(key))
                cache.Remove(key);
            cache.Add(key, value, expiratTime);
        }

        /// 
        /// 删除缓存数据项
        /// 
        /// 
        public static void Remove(string key)
        {
            cache.Remove(key);
        }

        /// 
        /// 删除所有缓存数据项
        /// 
        public static void RemoveAll()
        {
            cache.RemoveAll();
        }
        #endregion
    }

缓存优化

/// 
    /// 永不过期：当前就是
    /// 绝对过期：过了多长时间以后，就过期了 就不能用了
    /// 滑动过期：设定好过期时间后，如果在有效期内使用过，就往后滑动
    /// 1.Value;数据；
    /// 2.过期时间点：
    /// 3.滑动时间
    /// 普通cache
    /// 
    public class CustomCache
    {
        static CustomCache() //CLR调用  整个进程执行且只执行一次
        {
            Task.Run(() => //
            {
                while (true) //死循环来判断
                {
                    try
                    {
                        List<string> delKeyList = new List<string>();

                        lock (obj_Lock)
                        {
                            foreach (var key in CustomCacheDictionary.Keys)
                            {
                                DataModel model = CustomCacheDictionary[key];
                                if (model.Deadline < DateTime.Now && model.ObsloteType != ObsloteType.Never)
                                {
                                    delKeyList.Add(key);
                                }
                            }
                        }
                        delKeyList.ForEach(key => Remove(key));
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                        throw;
                    }
                }
            });
        }

        /// 
        /// static:不会被Gc回收；
        /// Private：不让外部访问他 
        /// 
        private static Dictionary<string, DataModel> CustomCacheDictionary = new Dictionary<string, DataModel>();

        private static readonly object obj_Lock = new object();


        /// 
        /// 默认你是不过期
        /// 
        /// 
        /// 
        public static void Add(string key, object value)
        {
            lock (obj_Lock)
                CustomCacheDictionary.Add(key, new DataModel()
                {
                    Value = value,
                    ObsloteType = ObsloteType.Never
                });
        }

        /// 
        /// 绝对过期
        /// 
        /// 
        /// 
        /// 
        public static void Add(string key, object value, int timeOutSecond) //3000
        {
            lock (obj_Lock)
                CustomCacheDictionary.Add(key, new DataModel()
                {
                    Value = value,
                    ObsloteType = ObsloteType.Absolutely,
                    Deadline = DateTime.Now.AddSeconds(timeOutSecond)
                }); ;
        }

        public static void Add(string key, object value, TimeSpan durtion)
        {
            lock (obj_Lock)
                CustomCacheDictionary.Add(key, new DataModel()
                {
                    Value = value,
                    ObsloteType = ObsloteType.Relative,
                    Deadline = DateTime.Now.Add(durtion),
                    Duraton = durtion
                }); ; ;
        }


        //清楚所有缓存，殃及池鱼！
        public static void RemoveAll()
        {
            lock (obj_Lock)
                CustomCacheDictionary.Clear();//字典中的所有内容全部被清理到
        }

        public static void Remove(string key)
        {
            lock (obj_Lock)
                CustomCacheDictionary.Remove(key);
        }

        public static void RemoveCondition(Func<string, bool> func)
        {
            List<string> keyList = new List<string>();
            lock (obj_Lock)
                foreach (var key in CustomCacheDictionary.Keys)
                {
                    if (func.Invoke(key))
                    {
                        keyList.Add(key);
                    }
                }
            keyList.ForEach(s => Remove(s));
        }

        public static T Get<T>(string key)
        {
            return (T)(CustomCacheDictionary[key]).Value;
        }

        public static bool Exists(string key)
        {
            if (CustomCacheDictionary.ContainsKey(key))
            {
                DataModel model = CustomCacheDictionary[key];
                if (model.ObsloteType == ObsloteType.Never)
                {
                    return true;
                }
                else if (model.Deadline < DateTime.Now) //
                {
                    lock (obj_Lock)
                    {

                        CustomCacheDictionary.Remove(key);
                        return false;
                    }

                }
                else
                {
                    if (model.ObsloteType == ObsloteType.Relative)
                    {
                        model.Deadline = DateTime.Now.Add(model.Duraton);
                    }
                    return true;
                }
            }
            else
            {
                return false;
            }
        }

        public static T GetT<T>(string key, Func<T> func)
        {
            T t = default(T);
            if (!Exists(key))
            {
                t = func.Invoke();
                Add(key, t);
            }
            else
            {
                t = Get<T>(key);
            }
            return t;
        }
    }
    /// 
    /// 线程安全cache
    /// 
    public class CustomCacheNew
    {

        static CustomCacheNew() //
        {
            Task.Run(() => //
            {
                while (true) //死循环来判断
                {
                    try
                    {
                        //Thread.Sleep(60 * 1000 * 10); //十分钟后开始清理缓存
                        List<string> delKeyList = new List<string>();
                        foreach (var key in CustomCacheDictionary.Keys)
                        {
                            DataModel model = CustomCacheDictionary[key];
                            if (model.Deadline < DateTime.Now && model.ObsloteType != ObsloteType.Never) //
                            {
                                delKeyList.Add(key);
                            }
                        }
                        delKeyList.ForEach(key => Remove(key));
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                        throw;
                    }
                }
            });

        }

        /// 
        /// static:不会被Gc回收；
        /// Private：不让外部访问他 
        /// 
        /// 线程安全字典
        /// 
        private static ConcurrentDictionary<string, DataModel> CustomCacheDictionary = new ConcurrentDictionary<string, DataModel>();

        /// 
        /// 默认你是不过期
        /// 
        /// 
        /// 
        public static void Add(string key, object value)
        {
            CustomCacheDictionary.TryAdd(key, new DataModel()
            {
                Value = value,
                ObsloteType = ObsloteType.Never
            });
        }

        /// 
        /// 绝对过期
        /// 
        /// 
        /// 
        /// 
        public static void Add(string key, object value, int timeOutSecond) //3000
        {
            CustomCacheDictionary.TryAdd(key, new DataModel()
            {
                Value = value,
                ObsloteType = ObsloteType.Absolutely,
                Deadline = DateTime.Now.AddSeconds(timeOutSecond)
            }); ;
        }

        public static void Add(string key, object value, TimeSpan durtion)
        {
            CustomCacheDictionary.TryAdd(key, new DataModel()
            {
                Value = value,
                ObsloteType = ObsloteType.Relative,
                Deadline = DateTime.Now.Add(durtion),
                Duraton = durtion
            }); ; ;
        }


        //清楚所有缓存，殃及池鱼！
        public static void RemoveAll()
        {
            CustomCacheDictionary.Clear();//字典中的所有内容全部被清理到
        }

        public static void Remove(string key)
        {
            DataModel data = null;
            CustomCacheDictionary.TryRemove(key, out data);
        }

        
        public static T Get<T>(string key)
        {
            return (T)(CustomCacheDictionary[key]).Value;
        }

        /// 
        /// 判断是否存在
        /// 
        /// 
        /// 
        public static bool Exists(string key)
        {
            
            if (CustomCacheDictionary.ContainsKey(key))
            {
                DataModel model = CustomCacheDictionary[key];
                if (model.ObsloteType == ObsloteType.Never)
                {
                    return true;
                }
                else if (model.Deadline < DateTime.Now) //
                {
                    DataModel data = null;
                    CustomCacheDictionary.TryRemove(key, out data);
                    return false;
                }
                else
                {
                    if (model.ObsloteType == ObsloteType.Relative)
                    {
                        model.Deadline = DateTime.Now.Add(model.Duraton);
                    }
                    return true;
                }
            }
            else
            {
                return false;
            }
        }

        public static T GetT<T>(string key, Func<T> func)
        {
            T t = default(T);
            if (!Exists(key))
            {
                t = func.Invoke();
                Add(key, t);
            }
            else
            {
                t = Get<T>(key);
            }
            return t;
        }
    }

    internal class DataModel
    {
        public object Value { get; set; }

        public ObsloteType ObsloteType { get; set; }

        public DateTime Deadline { get; set; }

        public TimeSpan Duraton { get; set; }
    }

    public enum ObsloteType
    {
        Never,
        Absolutely,
        Relative
    }

    /// 
    /// 解决性能问题
    /// 
    public class CustomCacheNewproblem
    {

        private static List<Dictionary<string, DataModel>> dicCacheList = new List<Dictionary<string, DataModel>>();
        private static List<object> lockList = new List<object>();

        public static int CupNum = 0;
        static CustomCacheNewproblem()
        {
            CupNum = 3;//模拟获取获取CPU片数  
            //动态生成字典
            for (int i = 0; i < CupNum; i++)
            {
                dicCacheList.Add(new Dictionary<string, DataModel>()); //CPU 有几片 就来几个字典
                lockList.Add(new object());//没个字典对应一个锁
            }


            Task.Run(() => //
            {
                while (true) //死循环来判断
                {
                    try
                    {

                        for (int i = 0; i < CupNum; i++)
                        {
                            lock (lockList[i])
                            { 
                                //Thread.Sleep(60 * 1000 * 10); //十分钟后开始清理缓存
                                List<string> delKeyList = new List<string>();
                                foreach (var key in dicCacheList[i].Keys)
                                {
                                    DataModel model = dicCacheList[i][key];
                                    if (model.Deadline < DateTime.Now && model.ObsloteType != ObsloteType.Never) //
                                    {
                                        delKeyList.Add(key);
                                    }
                                } 
                                delKeyList.ForEach(key => dicCacheList[i].Remove(key));
                            }
                        }

                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                        throw;
                    }
                }
            });

        }

        /// 
        /// 默认你是不过期
        /// 
        /// 
        /// 
        public static void Add(string key, object value)
        {
            int hash = key.GetHashCode() * (-1); //只要字符串变，hash值不变！
            int index = hash % CupNum;
            lock (lockList[index])
                dicCacheList[index].Add(key, new DataModel()
                {
                    Value = value,
                    ObsloteType = ObsloteType.Never
                });
        }

        /// 
        /// 绝对过期
        /// 
        /// 
        /// 
        /// 
        public static void Add(string key, object value, int timeOutSecond) //3000
        {
            int hash = key.GetHashCode() * (-1); //只要字符串变，hash值不变！
            int index = hash % CupNum;
            lock (lockList[index])
                dicCacheList[index].Add(key, new DataModel()
                {
                    Value = value,
                    ObsloteType = ObsloteType.Absolutely,
                    Deadline = DateTime.Now.AddSeconds(timeOutSecond)
                }); ;
        }

        public static void Add(string key, object value, TimeSpan durtion)
        {
            int hash = key.GetHashCode() * (-1); //只要字符串变，hash值不变！
            int index = hash % CupNum;
            lock (lockList[index])
                dicCacheList[index].Add(key, new DataModel()
                {
                    Value = value,
                    ObsloteType = ObsloteType.Relative,
                    Deadline = DateTime.Now.Add(durtion),
                    Duraton = durtion
                }); ; ;
        }


        //清楚所有缓存，殃及池鱼！
        public static void RemoveAll()
        {
            for (int i = 0; i < CupNum; i++)
            {
                dicCacheList[i].Clear();
            }
        }

        public static void Remove(string key)
        {
            int hash = key.GetHashCode() * (-1); //只要字符串变，hash值不变！
            int index = hash % CupNum;

            if (dicCacheList[index].ContainsKey(key))
            {
                dicCacheList[index].Remove(key);
            }

        }

       
        public static T Get<T>(string key)
        {
            int hash = key.GetHashCode() * (-1); //只要字符串变，hash值不变！
            int index = hash % CupNum;

            return (T)(dicCacheList[index][key]).Value;
        }

        /// 
        /// 判断是否存在
        /// 
        /// 
        /// 
        public static bool Exists(string key)
        {
            int hash = key.GetHashCode() * (-1); //只要字符串变，hash值不变！
            int index = hash % CupNum;
            if (dicCacheList[index].ContainsKey(key))
            {
                DataModel model = dicCacheList[index][key];
                if (model.ObsloteType == ObsloteType.Never)
                {
                    return true;
                }
                else if (model.Deadline < DateTime.Now) //
                {
                    dicCacheList[index].Remove(key);
                    return false;
                }
                else
                {
                    if (model.ObsloteType == ObsloteType.Relative)
                    {
                        model.Deadline = DateTime.Now.Add(model.Duraton);
                    }
                    return true;
                }
            }
            else
            {
                return false;
            }
        }

        public static T GetT<T>(string key, Func<T> func)
        {
            T t = default(T);
            if (!Exists(key))
            {
                t = func.Invoke();
                Add(key, t);
            }
            else
            {
                t = Get<T>(key);
            }
            return t;
        }
    }

C#中使用split分割字符串互联网打工人no1 c#
1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
你可能遗漏的一些C#/.NET/.NET Core知识点追逐时光者 C#.NET DotNetGuide编程指南 c#.net .netcore microsoft
前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
Android应用性能优化轻口味 Android
Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
华为云分布式缓存服务DCS 8月新特性发布华为云PaaS服务小智华为云分布式缓存
分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
Redis:缓存击穿我的程序快快跑啊缓存 redis java
缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
L1 L2 L3 缓存京天不下雨 windows 缓存 windows
L1L2L3缓存L1Cache(一级bai缓存)是CPU第一层高速缓存，分为数据缓存和指令缓存。du内置的zhiL1高速缓存的容量和结构对daoCPU的性能影响较大，不过高速缓冲存储器均由静态RAM组成，结构较复杂，在CPU管芯面积不能太大的情况下，L1级高速缓存的容量不可能做得太大。一般服务器CPU的L1缓存的容量通常在32—4096KB。L2由于L1级高速缓存容量的限制，为了再次提高CPU的运
C#动态加载DLL程序集及使用反射创建实例-简记不全 C#相关 Asp.net WebForm Asp.net MVC c#Assembly 反射程序集
Assembly动态加载程序集：分两种情况：1、需要加载的程序集已经在程序中被引用了，则直接从当前程序域中查找即可：Assemblyassembly=AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x=>x.GetName().Name.Contains("theAssemblyName"));2、需要加载的程序集未被加载，则使用程序集
开发游戏的学习规划杰克逊的日记游戏学习
第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
非关系型数据库天秤-white nosql
一、为什么要用Nosql1.单机MySQL的时代。一个基本的网站访问量一般不会太大，单个数据库完全足够。那时候更多使用的静态网页html，服务器根本没有太大压力。这时候网站的瓶颈是什么？-数据量如果太大，一个机器放不下。-数据量太大需要建立数据的索引（B+Tree），一个服务器内存放不下。-访问量读写混合，一个服务器承受不了。2.memcached缓存+MySQL+垂直拆分（读写分离）。网站80%
mybatis 二级缓存失效_Mybatis 缓存原理及失效情况解析 weixin_39844942 mybatis 二级缓存失效
这篇文章主要介绍了Mybatis缓存原理及失效情况解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、什么是缓存[Cache]存在内存中的临时数据。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。2、为什么要使用缓存减少和数据库的交互次
python可以制作大型游戏_python能做游戏吗-python能开发游戏吗靖dede python可以制作大型游戏
python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
详解mybatis的一二级缓存以及缓存失效原因仰望天花板缓存数据库 mybatis java mysql
数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
【C#生态园】深度剖析：C#嵌入式开发工具大揭秘 friklogff C#生态园 c#开发语言
C#嵌入式开发：全面了解六大框架与库前言随着物联网和嵌入式系统的快速发展，越来越多的开发者开始关注使用C#语言进行嵌入式开发。本文将介绍几种用于C#的嵌入式开发框架和相关库，以及它们的核心功能、安装配置方法和API概览，帮助读者了解并选择适合自己项目的工具和资源。欢迎订阅专栏：C#生态园文章目录C#嵌入式开发：全面了解六大框架与库前言1.nanoFramework：一个用于C#的嵌入式开发框架1.
Lua 与 C#交互 z2014z lua c#开发语言
Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
Golang channel 死锁羊城程序猿 golang golang
死锁是指两个或两个以上的协程的执行过程中，由于竞争资源或由于彼此通信而造成的一种阻塞的现象，若无外力作用，他们将无法推进下去,以下是总结出来的几种死锁情况。1.死锁1：一个通道在一个主go程里同时进行读和写2.死锁2：go程开启之前使用通道3.死锁3：通道1中调用了通道2，通道2中调用通道14.死锁4：直接读取空channel的死锁5.死锁5：超过channel缓存继续写入数据导致死锁6.向已关闭
C# 开发教程-入门基础天马3798 教程系列整理 c#开发语言
1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
C# 禁止程序重复启动 wiseyao1219 c#
修改：Program.cs[STAThread]staticvoidMain(){Mutexmutex=newMutex(true,"NewGuid123456",outboolisCreatedNew);if(!isCreatedNew){MessageBox.Show(Application.ProductName+"isrunning...");return;}Application.Ena
C#中判断socket是否已断开的方法 wiseyao1219 c#
代码如下：Sockets=newSocket(..);if(s.Poll(-1,SelectMode.SelectRead)){intnRead=s.Receive();if(nRead==0){//socket连接已断开}}参考：C#中判断socket是否已断开的方法
Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商 weixin_34302561 数据库 devops 大数据
1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
Three.js AnimationUtils 和 AnimationObjectGroup 灵魂清零 three 前端 web3 javascript
AnimationObjectGroup接收共享动画状态的一组对象。在使用手册的“下一步”章节中，“动画系统”一文对three.js动画系统中的不同元素作出了概述用法:将本来要作为根对象传入构造器或者动画混合器(AnimationMixer)的clipAction方法中的对象加入组中，并将这个组对象作为根对象传递。注意，这个类的实例作为混合器中的一个对象，因此，必须对组内的单个对象做缓存控制。限制
华为云分布式缓存服务DCS与开源服务差异对比 hcinfo_18 redis使用华为云 Redis5.0 分布式缓存服务 Redis客户端
分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
Linux中open函数详解 460833359 Linux C linux open函数
初级文件I/O函数（即不用缓存的I/O函数）：open（打开文件）相关函数read，write，fcntl，create，lseek，close，link，stat，umask，unlink，fopen头文件#include#include#include定义函数intopen(constchar*pathname,intflags);intopen(constchar*pathname,intf
页面报错 POST 413错误 (Request Entity Too Large) 小黑屋说YYDS 踩坑 nginx java linux 服务器
一般来说是服务器使用nginx作为反向代理出现的问题，post请求长度超过了nginx默认的缓存大小和最大客户端最大请求大小。解决方式如下，更该nginx代理配置：在nginx.conf配置文件中，找到http{}代码块，添加如下配置client_max_body_size20m;重启nginx即可。
数据库连接池幻影翔
连接池的意义作用：连接池是将已经创建好的连接保存在池中，当有请求来时，直接使用已经创建好的连接对数据库进行访问。这样省略了创建连接和销毁连接的过程。这样性能上得到了提高。连接池放了N个Connection对象，本质上放在内存当中，在内存中划出一块缓存对象，应用程序每次从池里获得Connection对象，而不是直接从数据里获得，这样不占用服务器的内存资源。两种优秀的连接池技术都要实现接口DataSo
【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析 "小夜猫&小懒虫&小财迷"的男人鸿蒙OH-v5.0源码分析之 Uboot+Kernel 部分 harmonyos linux 华为
【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
C#文件被占用的解决方案花北城 C#项目文件占用
问题打更新包时，提示文件被占用。System.IO.IOException:文件“D:\RS\RS_CCVI20111210.exe”正由另一进程使用，因此该进程无法访问该文件。在System.IO.__Error.WinIOError(Int32errorCode,StringmaybeFullPath)在System.IO.FileStream.Init(Stringpath,FileMode
npm install报错npm ERR! code CERT_HAS_EXPIRED 夏早安 npm 前端 node.js
报错如图解决办法：强制清缓存，取消ssl验证1.npmcacheclean--force2.npmconfigsetstrict-sslfalse3.重新npminstall4.依赖下载成功
清除 Conda 缓存 Dmatteratall conda 缓存
清除Conda缓存：cssCopycodecondaclean--allcondaclean--all命令将会清除Conda缓存和临时文件，而不会删除已经安装的软件包和环境。它主要用于清理不必要的缓存和临时文件以释放磁盘空间。
C#实现软件自动升级 BruceEditCode
winform程序相对web程序而言，功能更强大，编程更方便，但软件更新却相当麻烦，要到客户端一台一台地升级，本文结合实际情况，通过软件实现自动升级，弥补了这一缺陷，有较好的参考价值。由于程序在运行时不能用新的版本覆盖自己，因此，我们将登录窗口单独做成一个可执行文件，用户登录时，从网上检测是否有新的主程序，如果有，则从后台下载并覆盖老的版本，用户输入正确的用户名和密码后，通过参数将必要的信息（如用
C# 自动化 TineAine C#代码片段自动化 c#自动化模拟操作
实现的方法可能很笨，但是确实很好用usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Runtime.InteropServices;usingSystem.Text;usingSystem.Threading;usingSystem.Threading.Tasks;/******************
SAX解析xml文件小猪猪08 xml
1.创建SAXParserFactory实例 2.通过SAXParserFactory对象获取SAXParser实例 3.创建一个类SAXParserHander继续DefaultHandler，并且实例化这个类 4.SAXParser实例的parse来获取文件 public static void main(String[] args) { //
为什么mysql里的ibdata1文件不断的增长？ brotherlamp linux linux运维 linux资料 linux视频 linux运维自学
我们在 Percona 支持栏目经常收到关于 MySQL 的 ibdata1 文件的这个问题。当监控服务器发送一个关于 MySQL 服务器存储的报警时，恐慌就开始了 —— 就是说磁盘快要满了。一番调查后你意识到大多数地盘空间被 InnoDB 的共享表空间 ibdata1 使用。而你已经启用了 innodbfileper_table，所以问题是： ibdata1存了什么？当你启用了 i
Quartz-quartz.properties配置 eksliang quartz
其实Quartz JAR文件的org.quartz包下就包含了一个quartz.properties属性配置文件并提供了默认设置。如果需要调整默认配置，可以在类路径下建立一个新的quartz.properties，它将自动被Quartz加载并覆盖默认的设置。下面是这些默认值的解释 #-----集群的配置 org.quartz.scheduler.instanceName =
informatica session的使用 18289753290 workflow session log Informatica
如果希望workflow存储最近20次的log，在session里的Config Object设置，log options做配置，save session log :sessions run ;savesessio log for these runs:20 session下面的source 里面有个tracing
Scrapy抓取网页时出现CRC check failed 0x471e6e9a != 0x7c07b839L的错误酷的飞上天空 scrapy
Scrapy版本0.14.4 出现问题现象： ERROR: Error downloading <GET http://xxxxx CRC check failed 解决方法 1.设置网络请求时的header中的属性'Accept-Encoding': '*;q=0' 明确表示不支持任何形式的压缩格式，避免程序的解压
java Swing小集锦永夜-极光 java swing
1.关闭窗体弹出确认对话框 1.1 this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE); 1.2 this.addWindowListener ( new WindowAdapter () { public void windo
强制删除.svn文件夹随便小屋 java
在windows上，从别处复制的项目中可能带有.svn文件夹，手动删除太麻烦，并且每个文件夹下都有。所以写了个程序进行删除。因为.svn文件夹在windows上是只读的，所以用File中的delete()和deleteOnExist()方法都不能将其删除，所以只能采用windows命令方式进行删除
GET和POST有什么区别？及为什么网上的多数答案都是错的。 aijuans get post
如果有人问你，GET和POST，有什么区别？你会如何回答？我的经历前几天有人问我这个问题。我说GET是用于获取数据的，POST，一般用于将数据发给服务器之用。这个答案好像并不是他想要的。于是他继续追问有没有别的区别？我说这就是个名字而已，如果服务器支持，他完全可以把G
谈谈新浪微博背后的那些算法 aoyouzi 谈谈新浪微博背后的那些算法
本文对微博中常见的问题的对应算法进行了简单的介绍，在实际应用中的算法比介绍的要复杂的多。当然，本文覆盖的主题并不全，比如好友推荐、热点跟踪等就没有涉及到。但古人云“窥一斑而见全豹”，希望本文的介绍能帮助大家更好的理解微博这样的社交网络应用。微博是一个很多人都在用的社交应用。天天刷微博的人每天都会进行着这样几个操作：原创、转发、回复、阅读、关注、@等。其中，前四个是针对短博文，最后的关注和@则针
Connection reset 连接被重置的解决方法百合不是茶 java 字符流连接被重置
流是java的核心部分,,昨天在做android服务器连接服务器的时候出了问题,就将代码放到java中执行,结果还是一样连接被重置被重置的代码如下; 客户端代码; package 通信软件服务器; import java.io.BufferedWriter; import java.io.OutputStream; import java.io.O
web.xml配置详解之filter bijian1013 java web.xml filter
一.定义 <filter> <filter-name>encodingfilter</filter-name> <filter-class>com.my.app.EncodingFilter</filter-class> <init-param> <param-name>encoding<
Heritrix Bill_chen 多线程 xml 算法制造配置管理
作为纯Java语言开发的、功能强大的网络爬虫Heritrix，其功能极其强大，且扩展性良好，深受热爱搜索技术的盆友们的喜爱，但它配置较为复杂，且源码不好理解，最近又使劲看了下，结合自己的学习和理解，跟大家分享Heritrix的点点滴滴。 Heritrix的下载（http://sourceforge.net/projects/archive-crawler/）安装、配置，就不罗嗦了，可以自己找找资
【Zookeeper】FAQ bit1129 zookeeper
1.脱离IDE，运行简单的Java客户端程序 #ZkClient是简单的Zookeeper~$ java -cp "./:zookeeper-3.4.6.jar:./lib/*" ZKClient 1. Zookeeper是的Watcher回调是同步操作，需要添加异步处理的代码 2. 如果Zookeeper集群跨越多个机房，那么Leader/
The user specified as a definer ('aaa'@'localhost') does not exist 白糖_ localhost
今天遇到一个客户BUG，当前的jdbc连接用户是root，然后部分删除操作都会报下面这个错误：The user specified as a definer ('aaa'@'localhost') does not exist 最后找原因发现删除操作做了触发器，而触发器里面有这样一句 /*!50017 DEFINER = ''aaa@'localhost' */ 原来最初
javascript中showModelDialog刷新父页面 bozch JavaScript 刷新父页面 showModalDialog
在页面中使用showModalDialog打开模式子页面窗口的时候，如果想在子页面中操作父页面中的某个节点，可以通过如下的进行： window.showModalDialog('url',self,‘status...’); // 首先中间参数使用self 在子页面使用w
编程之美-买书折扣 bylijinnan 编程之美
import java.util.Arrays; public class BookDiscount { /**编程之美买书折扣书上的贪心算法的分析很有意思，我看了半天看不懂，结果作者说，贪心算法在这个问题上是不适用的。。下面用动态规划实现。哈利波特这本书一共有五卷，每卷都是8欧元，如果读者一次购买不同的两卷可扣除5%的折扣，三卷10%，四卷20%，五卷
关于struts2.3.4项目跨站执行脚本以及远程执行漏洞修复概要 chenbowen00 struts WEB安全
因为近期负责的几个银行系统软件，需要交付客户，因此客户专门请了安全公司对系统进行了安全评测，结果发现了诸如跨站执行脚本，远程执行漏洞以及弱口令等问题。下面记录下本次解决的过程以便后续 1、首先从最简单的开始处理，服务器的弱口令问题，首先根据安全工具提供的测试描述中发现应用服务器中存在一个匿名用户，默认是不需要密码的，经过分析发现服务器使用了FTP协议，而使用ftp协议默认会产生一个匿名用
[电力与暖气]煤炭燃烧与电力加温 comsci
在宇宙中,用贝塔射线观测地球某个部分,看上去,好像一个个马蜂窝,又像珊瑚礁一样,原来是某个国家的采煤区..... 不过,这个采煤区的煤炭看来是要用完了.....那么依赖将起燃烧并取暖的城市,在极度严寒的季节中...该怎么办呢? &nbs
oracle O7_DICTIONARY_ACCESSIBILITY参数 daizj oracle
O7_DICTIONARY_ACCESSIBILITY参数控制对数据字典的访问.设置为true,如果用户被授予了如select any table等any table权限,用户即使不是dba或sysdba用户也可以访问数据字典.在9i及以上版本默认为false,8i及以前版本默认为true.如果设置为true就可能会带来安全上的一些问题.这也就为什么O7_DICTIONARY_ACCESSIBIL
比较全面的MySQL优化参考 dengkane mysql
本文整理了一些MySQL的通用优化方法，做个简单的总结分享，旨在帮助那些没有专职MySQL DBA的企业做好基本的优化工作，至于具体的SQL优化，大部分通过加适当的索引即可达到效果，更复杂的就需要具体分析了，可以参考本站的一些优化案例或者联系我，下方有我的联系方式。这是上篇。 1、硬件层相关优化 1.1、CPU相关在服务器的BIOS设置中，可
C语言homework2，有一个逆序打印数字的小算法 dcj3sjt126com c
#h1# 0、完成课堂例子 1、将一个四位数逆序打印 1234 ==> 4321 实现方法一： # include <stdio.h> int main(void) { int i = 1234; int one = i%10; int two = i / 10 % 10; int three = i / 100 % 10;
apacheBench对网站进行压力测试 dcj3sjt126com apachebench
ab 的全称是 ApacheBench ，是 Apache 附带的一个小工具，专门用于 HTTP Server 的 benchmark testing ，可以同时模拟多个并发请求。前段时间看到公司的开发人员也在用它作一些测试，看起来也不错，很简单，也很容易使用，所以今天花一点时间看了一下。通过下面的一个简单的例子和注释，相信大家可以更容易理解这个工具的使用。
2种办法让HashMap线程安全 flyfoxs java jdk jni
多线程之--2种办法让HashMap线程安全多线程之--synchronized 和reentrantlock的优缺点多线程之--2种JAVA乐观锁的比较( NonfairSync VS. FairSync) HashMap不是线程安全的,往往在写程序时需要通过一些方法来回避.其实JDK原生的提供了2种方法让HashMap支持线程安全.
Spring Security（04）——认证简介 234390216 Spring Security 认证过程
认证简介目录 1.1 认证过程 1.2 Web应用的认证过程 1.2.1 ExceptionTranslationFilter 1.2.2 在request之间共享SecurityContext 1
Java 位运算 Javahuhui java 位运算
// 左移( << ) 低位补0 // 0000 0000 0000 0000 0000 0000 0000 0110 然后左移2位后，低位补0： // 0000 0000 0000 0000 0000 0000 0001 1000 System.out.println(6 << 2);// 运行结果是24 // 右移( >> ) 高位补"
mysql免安装版配置 ldzyz007 mysql
1、my-small.ini是为了小型数据库而设计的。不应该把这个模型用于含有一些常用项目的数据库。 2、my-medium.ini是为中等规模的数据库而设计的。如果你正在企业中使用RHEL,可能会比这个操作系统的最小RAM需求(256MB)明显多得多的物理内存。由此可见，如果有那么多RAM内存可以使用，自然可以在同一台机器上运行其它服务。 3、my-large.ini是为专用于一个SQL数据
MFC和ado数据库使用时遇到的问题你不认识的休道人 sql C++mfc
=================================================================== 第一个 =================================================================== try{ CString sql; sql.Format("select * from p
表单重复提交Double Submits rensanning double
可能发生的场景： *多次点击提交按钮 *刷新页面 *点击浏览器回退按钮 *直接访问收藏夹中的地址 *重复发送HTTP请求（Ajax）（1）点击按钮后disable该按钮一会儿，这样能避免急躁的用户频繁点击按钮。这种方法确实有些粗暴，友好一点的可以把按钮的文字变一下做个提示，比如Bootstrap的做法： http://getbootstrap.co
Java String 十大常见问题 tomcat_oracle java 正则表达式
　1.字符串比较，使用“==”还是equals()? 　　"=="判断两个引用的是不是同一个内存地址(同一个物理对象)。　　equals()判断两个字符串的值是否相等。　　除非你想判断两个string引用是否同一个对象，否则应该总是使用equals()方法。　　如果你了解字符串的驻留(String Interning)则会更好地理解这个问题。　　
SpringMVC 登陆拦截器实现登陆控制 xp9802 springMVC
思路，先登陆后，将登陆信息存储在session中，然后通过拦截器，对系统中的页面和资源进行访问拦截，同时对于登陆本身相关的页面和资源不拦截。实现方法： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

(精华)2020年8月15日 C#基础知识点 cache缓存的实现

静态字段缓存基本使用

cache缓存封装

缓存管理中心

你可能感兴趣的:(C#,缓存)