项目开发过程中缓存的应用到处可见,下面这篇文章主要给大家介绍了关于C#中缓存的基本使用方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值.

前言

缓存主要是为了提高数据的读取速度。因为服务器和应用客户端之间存在着流量瓶颈,所以读取大容量数据时,使用缓存来直接为客户端服务,可以减少客户端与服务器端的数据交互,从而大大提高程序的性能。
缓存这个东西可大可小,小到一个静态的字段,大到将整个数据库Cache起来。项目开发过程中缓存的应用到处可见,本文主要介绍一下使用的方法,下面话不多说了,来一起看看详细的介绍吧

1.在ASP.NET中页面缓存的使用方法简单,只需要在aspx页的顶部加上一句声明即可:

<%@ OutputCache Duration=”100” VaryByParam=”none” %>
   Duration:缓存时间(秒为单位),必填属性

2.使用微软自带的类库System.Web.Caching

新手接触的话不建议直接使用微软提供的类库,因为这样对理解不够深刻。所以在这里我带大家自己写一套缓存操作方法,这样理解得更加清晰。
话不多说,代码开敲。

一、首先,先模拟数据来源。新建一个类,写一个数据操作方法(该方法耗时、耗资源)

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading;
  6. using System.Threading.Tasks;
  7. namespace Cache
  8. {
  9. public class CacheDataSource
  10. {
  11. /// <summary>
  12. /// 01.模拟从数据库读取数据
  13. /// 02.耗时、耗CPU
  14. /// </summary>
  15. /// <param name="count"></param>
  16. public static int GetDataByDB(int count)
  17. {
  18. Console.WriteLine("-------GetDataByDB-------");
  19. int result = 0;
  20. for (int i = count; i < 99999999; i++)
  21. {
  22. result += i;
  23. }
  24. Thread.Sleep(2000);
  25. return result;
  26. }
  27. }
  28. }

二、编写一个缓存操作类

2.1 构造一个字典型容器,用于存放缓存数据,权限设为private ,防止随意访问造成数据不安全性

//缓存容器
private static Dictionary CacheDictionary = new Dictionary();

2.2 构造三个方法(添加数据至缓存容器、从缓存容器获取数据、判断缓存是否存在)

  1. using System;
  2. using System.Collections.Generic;
  3. namespace Cache
  4. {
  5. public class CacheHelper
  6. {
  7. /// <summary>
  8. /// 缓存容器
  9. /// </summary>
  10. private static Dictionary<string, object> CacheDictionary = new Dictionary<string, object>();
  11. /// <summary>
  12. /// 添加缓存
  13. /// </summary>
  14. public static void Add(string key, object value)
  15. {
  16. CacheDictionary.Add(key, value);
  17. }
  18. /// <summary>
  19. /// 获取缓存
  20. /// </summary>
  21. public static T Get<T>(string key)
  22. {
  23. return (T)CacheDictionary[key];
  24. }
  25. /// <summary>
  26. /// 判断缓存是否存在
  27. /// </summary>
  28. /// <param name="key"></param>
  29. /// <returns></returns>
  30. public static bool Exsits(string key)
  31. {
  32. return CacheDictionary.ContainsKey(key);
  33. }
  34. }
  35. }

三、程序入口编写测试方法

3.1 先看一下普通情况不适用缓存,它的执行效率有多慢

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. namespace Cache
  7. {
  8. class Program
  9. {
  10. static void Main(string[] args)
  11. {
  12. for (int i = 1; i < 6; i++)
  13. {
  14. Console.WriteLine($"------第{i}次请求------");
  15. int result = CacheDataSource.GetDataByDB(666);
  16. Console.WriteLine($"第{i}次请求获得的数据为:{result}");
  17. }
  18. }
  19. }
  20. }

03.02.C#中缓存的基本使用方法 - 图1

3.2 接下来,我们编写缓存试用方法。概念无非就是根据key前往字典容器里查找是否有相对应缓存数据,有则直接调用,没有则生成并存入字典容器里。

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. namespace Cache
  7. {
  8. class Program
  9. {
  10. static void Main(string[] args)
  11. {
  12. for (int i = 1; i < 6; i++)
  13. {
  14. Console.WriteLine($"------第{i}次请求------");
  15. //int result = DataSource.GetDataByDB(666);
  16. int result = 0;
  17. //key的名字一定要确保请求的准确性 DataSource GetDataByDB 666缺一不可
  18. string key = "DataSource_GetDataByDB_666";
  19. if (CacheHelper.Exsits(key))
  20. {
  21. //缓存存在,直接获取原数据
  22. result = CacheHelper.Get<int>(key);
  23. }
  24. else
  25. {
  26. //缓存不存在,去生成缓存,并加入容器
  27. result = CacheDataSource.GetDataByDB(666);
  28. CacheHelper.Add(key, result);
  29. }
  30. Console.WriteLine($"第{i}次请求获得的数据为:{result}");
  31. }
  32. }
  33. }
  34. }

3.3 我们看看加入缓存之后的效率如何

03.02.C#中缓存的基本使用方法 - 图2

四、可以看到,瞬间完成。事已至此,缓存的使用基本是完成了。但是回过头来我们想想看。一个系统成百上千个地方使用缓存的话,那岂不是要写成百上千个if else判断缓存是否存在,然后获取?

答案显而易见,肯定不合理的。所以我们要对代码进行优化。

4.1 缓存操作类(CacheHelper)编写一个通用的获取方法

  1. using System;
  2. using System.Collections.Generic;
  3. namespace Cache
  4. {
  5. public class CacheHelper
  6. {
  7. /// <summary>
  8. /// 缓存获取方法
  9. /// </summary>
  10. /// <typeparam name="T"></typeparam>
  11. /// <param name="key">缓存字典容器对应key</param>
  12. /// <param name="func">委托方法 传入操作对象</param>
  13. /// <returns></returns>
  14. public static T GetCache<T>(string key, Func<T> func)
  15. {
  16. T t = default(T);
  17. if (CacheHelper.Exsits(key))
  18. {
  19. //缓存存在,直接获取原数据
  20. t = CacheHelper.Get<T>(key);
  21. }
  22. else
  23. {
  24. //缓存不存在,去生成缓存,并加入容器
  25. t = func.Invoke();
  26. CacheHelper.Add(key, t);
  27. }
  28. return t;
  29. }
  30. /// <summary>
  31. /// 缓存容器
  32. /// </summary>
  33. private static Dictionary<string, object> CacheDictionary = new Dictionary<string, object>();
  34. /// <summary>
  35. /// 添加缓存
  36. /// </summary>
  37. public static void Add(string key, object value)
  38. {
  39. CacheDictionary.Add(key, value);
  40. }
  41. /// <summary>
  42. /// 获取缓存
  43. /// </summary>
  44. public static T Get<T>(string key)
  45. {
  46. return (T)CacheDictionary[key];
  47. }
  48. /// <summary>
  49. /// 判断缓存是否存在
  50. /// </summary>
  51. /// <param name="key"></param>
  52. /// <returns></returns>
  53. public static bool Exsits(string key)
  54. {
  55. return CacheDictionary.ContainsKey(key);
  56. }
  57. }
  58. }

4.2 程序入口进行调用,传入的委托参数为lamad表达式优化后的代码

到这里,缓存的使用基本结束了。最好值得一提的是,缓存尽量在数据量小、重复查询量大的情况下使用。因为缓存也是要耗内存的,服务器内存是有限的!

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. namespace Cache
  7. {
  8. class Program
  9. {
  10. static void Main(string[] args)
  11. {
  12. for (int i = 1; i < 6; i++)
  13. {
  14. Console.WriteLine($"------第{i}次请求------");
  15. int result = 0;
  16. //key的名字一定要确保请求的准确性 DataSource GetDataByDB 666缺一不可
  17. string key = "DataSource_GetDataByDB_666";
  18. //将需要执行的获取数据操作编写成委托传入方法(重点)
  19. //Func<int> func = new Func<int>(() => { return DataSource.GetDataByDB(666); });
  20. result = CacheHelper.GetCache(key, () => DataSource.GetDataByDB(666));
  21. Console.WriteLine($"第{i}次请求获得的数据为:{result}");
  22. }
  23. }
  24. }
  25. }

总结

到这里,缓存的使用基本结束了。最好值得一提的是,缓存尽量在数据量小、重复查询量大的情况下使用。因为缓存也是要耗内存的,服务器内存是有限的!