.NET CORE 中的缓存使用

时间 2019-11-06

标签 core 缓存使用繁體版

原文原文链接

1 Net Framewoke的缓存

1.1 System.Web.Caching
　　System.Web.Caching应该是咱们最熟悉的缓存类库了，作ASP.NET开发时用到缓存基本都是使用的这个缓存组件，简单回顾一下用法吧


using System.Web;
using System.Web.Caching;

namespace FrameCache
{
    class Program
    {
        static void Main(string[] args)
        {
            //1.简单缓存,value能够是任何类型
            HttpRuntime.Cache.Insert("mykey", "myvalue");
            Console.WriteLine($"Key为mykey的缓存：{HttpRuntime.Cache["mykey"]}");


            //2.使用缓存依赖项
            string path = Path.Combine(Environment.CurrentDirectory, @"someCacheData.xml");
            DataSet ds = new DataSet();
            ds.ReadXml(path);
            if (HttpRuntime.Cache.Get("myxml") == null)
            {
                //Dataset添加到缓存
                System.Web.HttpRuntime.Cache.Insert("myxml", ds, new CacheDependency(path));
            }
            //从缓存中获取Dataset
            DataSet resultDs = (DataSet)HttpRuntime.Cache.Get("myxml");
            Console.WriteLine($"food下的f1节点：{resultDs.Tables["food"].Rows[0]["f1"]}");
            Console.ReadKey();
        }
    }
}

　　简单的缓存就不说了，添加一下key和value就能够，缓存依赖项CacheDependency是更新缓存的重要手段，但缓存依赖项发生变化时缓存就会被清理。上边栗子中缓存只依赖一个文件，当缓存依赖多个文件时能够这样设置：  CacheDependency cdp=new CacheDependency(new string []{"111.xml","222.xml"}); 。栗子中someCacheData.xml中的内容是：


<?xml version="1.0" encoding="utf-8" ?>
<MyCache>
  <animals>
    <a1>cat</a1>
    <a2>dog</a2>
  </animals>
  <food>
    <f1>apple</f1>
    <f2>pear</f2>
  </food>
</MyCache>

运行程序结果以下：

1.2 System.Runtime.Caching
　　Net Framework中的MemoryCache类就是来自于这个类库，也是开发中常常用到的类库，net core中的缓存用法和这个类库十分类似。简单看一下用法吧


using System.Runtime.Caching;
namespace FrameCache
{
    class Program
    {
        static void Main(string[] args)
        {
            //缓存的配置
            CacheItemPolicy policy = new CacheItemPolicy()
            {
                //缓存被删除是的回调
                RemovedCallback = (arguments) => { Console.WriteLine($"缓存被移除的缘由：{arguments.RemovedReason}"); },
                //滑动过时时间
                SlidingExpiration = TimeSpan.FromSeconds(5),
                //绝对过时时间
                //AbsoluteExpiration = DateTime.Now.AddSeconds(5),
                //优先级有两种：Default，NotRemovable(不可移除)
                Priority = System.Runtime.Caching.CacheItemPriority.NotRemovable
            };

            //添加缓存，key为mykey，值是myvalue ,
            System.Runtime.Caching.MemoryCache.Default.Add("mykey", "myvalue", policy);
            Thread.Sleep(6000);
            Console.WriteLine(MemoryCache.Default.Get("mykey"));
            Console.ReadKey();
        }
    }
}

　　CacheItemPolicy 对象用于对缓存项作一个设置，如设置绝对/滑动过时时间，优先级，缓存被清理时的回调函数等。程序运行结果以下，若是咱们把线程休眠的代码注释掉，则输出为 “myvlaue”。

2 Net core的缓存介绍
　　netcore中的缓存用户和 System.Runtime.Caching 很类似，可是在功能上作了加强：缓存的key能够支持object类型（.netframework中缓存key只支持string）；提供了泛型支持；能够对缓存和单个缓存项的大小作限定，能够设定缓存的压缩比例（如缓存最大设置为100M，压缩比例为0.2，那么缓存达到一百兆时会清除20M的缓存数据，清除时优先级低的缓存项会被优先清除）；此外微软提供了Sqlserver和Redis的缓存支持，可让咱们更方便地实现分布式缓存。

2.1 MemoryCache
1.过时时间　　
netcore中缓存相关的类库都在 Microsoft.Extensions.Caching ，使用MemoryCache首先安装包

Install-Package Microsoft.Extensions.Caching.Memory
使用的方式和基本同样，咱们简单看一下代码


using Microsoft.Extensions.Caching.Memory;
namespace CacheDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            MemoryCache memoryCache = new MemoryCache(new MemoryCacheOptions() { });
            //1.最简单使用方式
            memoryCache.Set("mykey", "myvalue");

            //2.绝对过时时间，3秒后过时
            memoryCache.Set("key1", "value1", new DateTimeOffset(DateTime.Now.AddSeconds(3)));
            //3.绝对过时时间，效果同上
            memoryCache.Set("key2", "value2", TimeSpan.FromSeconds(3));
            //4.滑动过时时间，3秒后,即三秒钟内被访问，则从新刷新缓存时间为3秒后
            memoryCache.Set("key3", "value3", new MemoryCacheEntryOptions
            {
                SlidingExpiration = TimeSpan.FromSeconds(3),
            });

            Console.WriteLine("-----------暂停2秒");
            Thread.Sleep(2000);//暂停2秒
            Console.WriteLine($"key1的值：{memoryCache.Get("key1") ?? "key1被清除"}");
            Console.WriteLine($"key2的值：{memoryCache.Get("key2") ?? "key2被清除"}");
            Console.WriteLine($"key3的值：{memoryCache.Get("key3") ?? "key3被清除"}");

            Console.WriteLine("-----------暂停2秒");
            Thread.Sleep(2000);//再次暂停2秒
            Console.WriteLine($"key1的值：{memoryCache.Get("key1") ?? "key1被清除"}");
            Console.WriteLine($"key2的值：{memoryCache.Get("key2") ?? "key2被清除"}");
            Console.WriteLine($"key3的值：{memoryCache.Get("key3") ?? "key3被清除"}");
        }
    }
}

　　在栗子中key1,key2都是使用的绝对过时时间，key3使用的相对过时时间，2秒后第一次访问key一、key二、key3都没过时，其中key3的过时时间刷新了，从新设置为3秒后，因此再次暂停2秒后，key一、key2都过时了，key3仍然存在。程序运行结果以下：

2.经常使用配置
上边咱们知道了netcore中缓存的简单用法，下边的栗子介绍netcore中缓存的经常使用配置，直接看代码


    class Program
    {
        static void Main(string[] args)
        {
            //缓存的配置
            MemoryCacheOptions cacheOps = new MemoryCacheOptions()
            {
                //缓存最大为100份
                //##注意netcore中的缓存是没有单位的，缓存项和缓存的相对关系
                SizeLimit = 100,
                //缓存满了时，压缩20%（即删除20份优先级低的缓存项）
                CompactionPercentage = 0.2,
                //两秒钟查找一次过时项
                ExpirationScanFrequency = TimeSpan.FromSeconds(3)
            };
            MemoryCache myCache = new MemoryCache(cacheOps);

            //单个缓存项的配置
            MemoryCacheEntryOptions cacheEntityOps = new MemoryCacheEntryOptions()
            {
                //绝对过时时间1
                //AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddSeconds(2)),
                //绝对过时时间2
                //AbsoluteExpirationRelativeToNow=TimeSpan.FromSeconds(3),
                //相对过时时间
                SlidingExpiration = TimeSpan.FromSeconds(3),
                //优先级，当缓存压缩时会优先清除优先级低的缓存项
                Priority = CacheItemPriority.Low,//Low,Normal,High,NeverRemove
                //缓存大小占1份
                Size = 1
            };
            //注册缓存项被清除时的回调，能够注册多个回调
            cacheEntityOps.RegisterPostEvictionCallback((key, value, reason, state) =>
            {
                Console.WriteLine($"回调函数输出【键:{key},值:{value},被清除的缘由:{reason}】");
            });

            myCache.Set("mykey", "myvalue", cacheEntityOps);
            Console.WriteLine($"mykey的值：{myCache.Get("mykey") ?? "mykey缓存被清除了"}");
            Console.WriteLine("------------------暂停3秒");
            Thread.Sleep(3000);
            Console.WriteLine($"mykey的值：{myCache.Get("mykey") ?? "mykey缓存被清除了"}");

            Console.ReadKey();
        }
    }
}

　　这里须要注意netcore中设置缓存和缓存项大小是没有单位的，缓存被清空的回调函数能够注册多个（System.Runtime.Caching清除缓存的回调只能是一个）。程序执行结果

3.IChangeToken
　　上边咱们已经简单了解了经过滑动过时时间和绝对过时时间来控制缓存的有效性，可是有时缓存的过时与否和时候没有联系，如咱们缓存一个文件的内容，无论缓存多久只要文件没有发生变化缓存都是有效的。在net framework中咱们能够经过CacheDependency来控制，在net core中怎么控制呢？net core中咱们可使用IChangeToken接口轻松实现缓存的过时策略。先看一下IChangeToken接口：


    public interface IChangeToken
    {
        // 是否有变化发生
        bool HasChanged { get; }

        // token是否会调用回调函数，为true时才会有效 
        bool ActiveChangeCallbacks { get; }

       // 注册一个回调函数，当有变化时触发回调
        IDisposable RegisterChangeCallback(Action<object> callback, object state);
    }

看一下IChangeToken实现缓存过时策略的两个例子：

① 监控文件


    class Program
    {
        static void Main(string[] args)
        {
            string fileName = Path.Combine(Environment.CurrentDirectory, "someCacheData.xml");
            FileInfo fileInfo = new FileInfo(fileName);
            MemoryCache myCache = new MemoryCache(new MemoryCacheOptions() { });
            MemoryCacheEntryOptions cacheEntityOps = new MemoryCacheEntryOptions();
            //PollingFileChangeToken是IChangeToken的实现类，经过轮询监控文件变化
            cacheEntityOps.AddExpirationToken(new Microsoft.Extensions.FileProviders.Physical.PollingFileChangeToken(fileInfo));
            //缓存失效时，回调函数
            cacheEntityOps.RegisterPostEvictionCallback((key, value, reason, state) => { Console.WriteLine($"文件【{key}】改动了"); });
           //添加缓存，key为文件名，value为文件内容
            myCache.Set(fileInfo.Name, File.ReadAllText(fileName), cacheEntityOps);
            Console.WriteLine(myCache.Get(fileInfo.Name));
        }
    }

　　PollingFileChangeToken经过轮询来监控文件有没有发生变化，若是文件中的内容发生改变，缓存就会自动过时。

② 经过代码控制缓存过时


    class Program
    {
        static void Main(string[] args)
        {
            MemoryCache memoryCache = new MemoryCache(new MemoryCacheOptions());
            MemoryCacheEntryOptions cacheEntityOps = new MemoryCacheEntryOptions();
            //使用CancellationChangeToken控制缓存过时
            CancellationTokenSource tokenSource = new CancellationTokenSource();
            cacheEntityOps.AddExpirationToken(new CancellationChangeToken(tokenSource.Token));
            //设置缓存
            memoryCache.Set("mykey", "myvalue", cacheEntityOps);
            Console.WriteLine(memoryCache.Get("mykey") ?? "缓存被清除了");
            //经过代码清除缓存
            tokenSource.Cancel();
            Console.WriteLine(memoryCache.Get("mykey") ?? "缓存被清除了");
        }
    }

　　tokenSource.Cancel方法发送取消信号，这个方法会触发缓存过时，基于此咱们能够经过Cancel方法灵活的实现自定义的缓存策略。程序执行结果以下：

2.2 RedisCache
　　微软给netcore的缓存提供了Redis和Sqlserver的实现，经过Sqlserver来缓存的场景比较少，这里咱们简单看一下官方提供的Redis缓存用法。

　　准备工做：我已经在一台Linu虚拟机上部署了Redis服务，虚拟机IP为192.168.70.99，Redis采用默认端口6379，密码是xxxxx。我开发使用的电脑能够链接到虚拟机上的Redis服务器。

　　首先添加包

Install-Package Microsoft.Extensions.Caching
Install-Package Microsoft.Extensions.Caching.Redis
　　而后咱们写一个简单的控制台程序实现一下netcore中的redis缓存实现，代码以下：


        static void Main(string[] args)
        {
            //获取RedisCache实例
            RedisCache redisCache = new RedisCache(new RedisCacheOptions()
            {
                Configuration = "192.168.70.99:6379,password=xxxxx",
                InstanceName = "MyData"
            });
            //在redis中是以hash表的模式存放的
            redisCache.SetString("Name", "jack");
            redisCache.SetString("Age", "20");
            redisCache.SetString("Address", "上海", new DistributedCacheEntryOptions()
            {
                //SlidingExpiration = TimeSpan.FromSeconds(3)
                AbsoluteExpiration = DateTimeOffset.Now.AddDays(1)
            });
            //获取缓存
            //Console.WriteLine(redisCache.GetString("Name"));
        }

　　执行完成，缓存数据以Hash表形式存储在redis中，以下：

　　这里只是介绍了netcore中redis缓存的简单用法，其实官方提供的Redis缓存扩展中的Api不多，远没有MemoryCache那么多，咱们使用netcore中的Redis缓存时,更多要使用Redis自身提供的功能。