分布式缓存学习总结

 1 using Memcached.ClientLibrary;
 2 using System;
 3 using System.Collections.Generic;
 4 using System.Linq;
 5 using System.Text;
 6 using System.Threading.Tasks;
 7 
 8 namespace 测试
 9 {
10     public class MemcacheTset
11     {
12         public static void Test()
13         {
14             string[] serverlist = { "127.0.0.1:11211" }; //服务器列表，可多个 用逗号隔开     
15             
16             //初始化池
17             SockIOPool pool = SockIOPool.GetInstance();
18 
19             //根据实际情况修改下面参数
20             pool.SetServers(serverlist);
21             pool.InitConnections = 3;
22             pool.MinConnections = 3;
23             pool.MaxConnections = 5;
24             pool.SocketConnectTimeout = 1000;
25             pool.SocketTimeout = 3000;
26             pool.MaintenanceSleep = 30;
27             pool.Failover = true;
28             pool.Nagle = false;
29             pool.Initialize(); // initialize the pool for memcache servers  
30          
31             //获得客户端实例
32             MemcachedClient mc = new MemcachedClient();//初始化一个客户端 
33             mc.EnableCompression = false;
34 
35             Console.WriteLine("---------测试----------");
36             mc.Set("test","my value");//存储数据到缓存服务器，这里将字符串"my value"缓存，key
37 
38             if (mc.KeyExists("test"))//测试缓存存在key为test的项目
39             {
40                 Console.WriteLine("test is Exists");
41                 Console.WriteLine(mc.Get("test").ToString());//在缓存中获取key为test的项目
42             }
43             else 
44             {
45                 Console.WriteLine("test not Exists");
46             }
47 
48             Console.ReadLine();
49 
50             mc.Delete("test");//移除缓存中key为test的项目
51 
52             if (mc.KeyExists("test"))
53             {
54                 Console.WriteLine("test is Exists");
55                 Console.WriteLine(mc.Get("test").ToString());
56             }
57             else
58             {
59                 Console.WriteLine("test not Exists");
60             }
61 
62             Console.ReadLine();
63 
64             SockIOPool.GetInstance().Shutdown();//关闭池，关闭sockets
65         }
66     }
67 }

 1 using Memcached.ClientLibrary;
 2 using System;
 3 using System.Collections.Generic;
 4 using System.Linq;
 5 using System.Text;
 6 using System.Threading.Tasks;
 7 
 8 namespace JOEY.BookShop.Common
 9 {
10     public class MemcacheHelper
11     {
12         private static readonly MemcachedClient mc;
13         static MemcacheHelper()
14         {
15             string[] serverlist = { "127.0.0.1:11211" }; //服务器列表，可多个 用逗号隔开     
16 
17             //初始化池
18             SockIOPool pool = SockIOPool.GetInstance();
19 
20             //根据实际情况修改下面参数
21             pool.SetServers(serverlist);
22             pool.InitConnections = 3;
23             pool.MinConnections = 3;
24             pool.MaxConnections = 5;
25             pool.SocketConnectTimeout = 1000;
26             pool.SocketTimeout = 3000;
27             pool.MaintenanceSleep = 30;
28             pool.Failover = true;
29             pool.Nagle = false;
30             pool.Initialize(); // initialize the pool for memcache servers  
31 
32             //获得客户端实例
33             mc = new MemcachedClient();//初始化一个客户端 
34             mc.EnableCompression = false;
35         }
36 
37         /// <summary>
38         /// 存
39         /// </summary>
40         /// <param name="key"></param>
41         /// <param name="value"></param>
42         public static void Set(string key, object value)
43         {
44             mc.Set(key, value);
45         }
46 
47         public static void Set(string key, object value, DateTime time)
48         {
49             mc.Set(key, value, time);
50         }
51 
52         /// <summary>
53         /// 取
54         /// </summary>
55         /// <param name="key"></param>
56         /// <returns></returns>
57         public static object Get(string key)
58         {
59             if (mc.KeyExists(key))
60             {
61                 return mc.Get(key);
62             }
63             else
64             {
65                 return null;
66             }
67             
68         }
69 
70         /// <summary>
71         /// 删除
72         /// </summary>
73         /// <param name="key"></param>
74         /// <returns></returns>
75         public static bool Delete(string key)
76         {
77             if (mc.KeyExists(key))
78             {
79                 mc.Delete(key);
80                 return true;
81             }
82             return false;
83         }
84     }
85 }

 1 using Newtonsoft.Json;
 2 using System;
 3 using System.Collections.Generic;
 4 using System.Linq;
 5 using System.Text;
 6 using System.Threading.Tasks;
 7 
 8 namespace JOEY.BookShop.Common
 9 {
10     /// <summary>
11     /// Json.Net 序列化，对于由于相互引用类型导致的序列化死循环，可在该对象上加个特性标签[JsonIgnore] 如在Model中有外键，两个模型间相互引用即造成该问题
12     /// </summary>
13     public class SerializeHelper
14     {
15         /// <summary>
16         /// 传入对象，序列化成字符串返回
17         /// </summary>
18         /// <param name="obj"></param>
19         /// <returns></returns>
20         public static string SerializeToString(object obj)
21         {
22             return JsonConvert.SerializeObject(obj);
23         }
24         /// <summary>
25         /// 传入序列化字符串，反序列化成对应对象返回
26         /// </summary>
27         /// <typeparam name="T">泛型，对应对象类型</typeparam>
28         /// <param name="serializeStr">序列化后的字符串</param>
29         /// <returns></returns>
30         public static T DeserializeToObject<T>(string serializeStr)
31         {
32             return JsonConvert.DeserializeObject<T>(serializeStr);
33         }
34     }
35 }