C# 缓存使用笔记

缓存技术是一大门槛，怎么构造缓存才是奇思妙解。我是这样认为的，因为一提及缓存，相信大家都能说出个一二的。实际操作是另外一回事的。我分享下我们业务可能会用到的场景。

目的就是从缓存中依次或者排队拿出数据，进而解决并发问题。缓存的学习和应用有一段时间了，推荐这个大佬的讲解https://www.cnblogs.com/wuhuacong/p/3526335.html

我的代码：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Runtime.Caching;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Test_缓存
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        List<Emtity> lst = new List<Emtity>();

        private void button1_Click(object sender, EventArgs e)
        {

            //for (int i = 0; i < 10; i++)
            //{
            //Emtity mod=new Emtity();
            //string str = UHastable<string>.Instance;
            //mod.Id = i+1;
            //mod.Name = str;
            //lst.Add(mod);
            //}

            //Emtity mod = UHastable<Emtity>.Instance;
            //lst.Add(mod);

            lst = UHastable<List<Emtity>>.InstanceList;

        }

        private void button2_Click(object sender, EventArgs e)
        {
            dataGridView1.DataSource = lst;
        }

        private void button3_Click(object sender, EventArgs e)
        {
            GetUserFullName("2");
        }

        /// <summary>
        /// 根据用户的ID，获取用户的全名，并放到缓存里面
        /// </summary>
        /// <param name="userId">用户的ID</param>
        /// <returns></returns>
        public string GetUserFullName(string userId)
        {
            string key = "Security_UserFullName" + userId;
            List<Emtity> lst_s = new List<Emtity>();
            Emtity mod = new Emtity();
            mod.Name = "333";
            lst_s.Add(mod);

            string fullName = MemoryCacheHelper.GetCacheItem<string>(key,
                delegate() { return lst_s[0].Name; },
                new TimeSpan(0, 30, 0)); //30分钟过期
            return fullName;
        }

        public List<Emtity> GetUsernName()
        {
            List<Emtity> lst_uuu = new List<Emtity>();
            string key = "Security_UserFullName22";
            Emtity mod = new Emtity();
            mod.Name = "333";
            lst_uuu.Add(mod);
            MemoryCacheHelper.GetCacheItem<List<Emtity>>(key,
                delegate() { return lst_uuu; },
                new TimeSpan(0, 30, 0)); //30分钟过期
            return lst_uuu;
        }
        string[] str=new string[10];
        private int index = 0;
        private void button4_Click(object sender, EventArgs e)
        {
            if (index >= 10)
            {
                MessageBox.Show("NO:"+ index.ToString());
                return;
            }
            for (int i = 0; i < str.Length; i++)
            {
                str[i] = "a" + i.ToString();
            }
            List<Emtity> lst_uuu = MemoryCacheHelper.GetCacheItem<List<Emtity>>(str[index],
                delegate()
                {
                    List<Emtity> lst_222 = new List<Emtity>();

                    Emtity mod = new Emtity();
                    mod.Id = index;
                    mod.Name = "333";
                    lst_222.Add(mod);
                    return lst_222;
                },
                new TimeSpan(0, 30, 0)); //30分钟过期
            index++;
        }

        private int count = 0;
        private void button5_Click(object sender, EventArgs e)
        {
            count++;
            index--;
           
            var s = MemoryCache.Default[str[index]];
            //假设业务需求是取出数据后就移除该数据 则
            MemoryCache.Default.Remove(str[index]);
            //让index=10 验证数据是否真正从缓存中移除了
            if (index == 0) index = 10;

           

            if (count >= 10 && count < 20)
            {
                //开始验证缓存中的数据是否为空
                if (s == null) MessageBox.Show("OK,该缓存地址为空。str["+ index + "]");
            }
            //假设所有缓存地址都为空了，这时可以释放该缓存地址了，也可以保留
            if (count >= 20)
            {
                MemoryCache.Default.Dispose();
                MessageBox.Show("OK，释放由 System.Runtime.Caching.MemoryCache 类的当前实例占用的所有资源。");
                return;
            }
            //假设要释放index=8时的缓存地址,然后验证下index<8的缓存地址释放有数据
            if (index <= 8)
            {
                MemoryCache.Default.Dispose();
                var s2= (List<Emtity>) MemoryCache.Default[str[index - 1]];
                string str55 =
                    string.Format("OK，释放了缓存地址的值str[{0}]，下一个值：str[{1}]={2}", index, index - 1,
                        s2 != null ? s2[0].Id.ToString() : "null");
                MessageBox.Show(str55);
            }
        }
    }

    public class Emtity
    {
        public int Id { get; set; }

        public string Name { get; set; }
    }

}

其他类：

MemoryCacheHelper：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Caching;
using System.Text;
using System.Threading.Tasks;

namespace Test_缓存
{
    public class MemoryCacheHelper
    {
        private static readonly  Object _locker=new object();
        
        public static T GetCacheItem<T>(String key, Func<T> cachePopulate, TimeSpan? slidingExpiration = null, DateTime? absoluteExpiration = null)
        {
            if (String.IsNullOrWhiteSpace(key)) throw new ArgumentException("Invalid cache key");
            if (cachePopulate == null) throw new ArgumentNullException("cachePopulate");
            if (slidingExpiration == null && absoluteExpiration == null) throw new ArgumentException("Either a sliding expiration or absolute must be provided");
            //引用 System.Runtime.Caching  https://docs.microsoft.com/zh-cn/dotnet/api/system.runtime.caching.memorycache?redirectedfrom=MSDN&view=netframework-4.8
            if (MemoryCache.Default[key] == null)
            {
                lock (_locker)
                {
                    if (MemoryCache.Default[key] == null)
                    {
                        var item = new CacheItem(key, cachePopulate());
                        var policy = CreatePolicy(slidingExpiration, absoluteExpiration);

                        MemoryCache.Default.Add(item, policy);
                    }
                }
            }

            return (T)MemoryCache.Default[key];
        }

        private static CacheItemPolicy CreatePolicy(TimeSpan? slidingExpiration, DateTime? absoluteExpiration)
        {
            var policy = new CacheItemPolicy();

            if (absoluteExpiration.HasValue)
            {
                policy.AbsoluteExpiration = absoluteExpiration.Value;
            }
            else if (slidingExpiration.HasValue)
            {
                policy.SlidingExpiration = slidingExpiration.Value;
            }

            policy.Priority = CacheItemPriority.Default;

            return policy;
        }
    }
}

Reflect：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Windows.Forms;

namespace Test_缓存
{
    public class Reflect<T> where T : class
    {
        public static T Create()
        {
            try
            {
                Random rd=new Random();
                Thread.Sleep(10);
                //T t = (T)(object)Convert.ToString(rd.Next(0, 9));
                Emtity et =new Emtity();
                et.Id = 1;
                et.Name = "LiuL";
                return (T)(object)et;
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());
                return null;
            }
           
            
        }

        public static T Create(int index)
        {
            try
            {
                Random rd = new Random();
                Thread.Sleep(10);
                //T t = (T)(object)Convert.ToString(rd.Next(0, 9));
                List<Emtity> lst=new List<Emtity>();
                for (int i = 0; i < index; i++)
                {
                    Emtity et = new Emtity();
                    et.Id = i+1;
                    et.Name = "LiuL"+ Convert.ToString(rd.Next(0, 9));
                    lst.Add(et);
                }
                return (T)(object)lst;
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());
                return null;
            }


        }
    }

}

UHastable：

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Test_缓存
{
    public class UHastable<T> where T: class
    {
        private  static  Hashtable objCache=new Hashtable();
        private static object syncRoot = new Object();

        private static int _Id;
        public static int Id { get; set; }
        public static T Instance
        {
            get
            {
                //string CacheKey = typeof(T).FullName;
                /*T bll= (T)objCache[CacheKey];*/  //从缓存读取  
                T bll = (T)objCache[_Id];
                if (bll == null)
                {
                    lock (syncRoot)
                    {
                        if (bll == null)
                        {
                            bll = Reflect<T>.Create();//反射创建，并缓存
                            objCache.Add(_Id, bll);
                        }
                    }
                }

                _Id++;
                return bll;
            }
            
        }

        public static T InstanceList
        {
            get
            {
                T bll = (T)objCache[_Id];
                if (bll == null)
                {
                    lock (syncRoot)
                    {
                        if (bll == null)
                        {
                            bll = Reflect<T>.Create(10);//反射创建，并缓存
                            objCache.Add(_Id, bll);
                        }
                    }
                }

                _Id++;
                return bll;
            }

        }
    }

    
}

测试数据都是模拟数据。