Memcached缓存帮助类

.NET Memcached分布式缓存帮助类

  1 using Memcached.ClientLibrary;
  2 using System;
  3 using System.Collections;
  4 using System.Collections.Generic;
  5 using System.Configuration;
  6 using System.Linq;
  7 using System.Text;
  8
  9 namespace Components.Helper
 10 {
 11     /// <summary>分布式缓存Memcach帮助类</summary>
 12     public class MemcachHelper
 13     {
 14         private static MemcachedClient _client;
 15         /// <summary>默认缓存时间(默认20分钟)</summary>
 16         public static int DefaultCacheTime = (!string.IsNullOrEmpty(ConfigurationManager.AppSettings["DefaultCacheTime"]) ? Convert.ToInt32(ConfigurationManager.AppSettings["DefaultCacheTime"]) : 1200000);
 17
 18         /// <summary>
 19         /// 是否启用分布式缓存
 20         /// </summary>
 21         public static bool IsEnableScatteredCache = (!string.IsNullOrEmpty(ConfigurationManager.AppSettings["IsEnableScatteredCache"]) ? Convert.ToBoolean(ConfigurationManager.AppSettings["IsEnableScatteredCache"]) : true);
 22         static MemcachHelper()
 23         {
 24             string[] serverlist = (!string.IsNullOrEmpty(ConfigurationManager.AppSettings["Memcached.ServerList"]) ? ConfigurationManager.AppSettings["Memcached.ServerList"].Split(‘,‘) : null);
 25
 26             if (null == serverlist)
 27             {
 28                 serverlist = new string[] { "127.0.0.1:11211" };
 29             }
 30
 31             SockIOPool pool = SockIOPool.GetInstance("First");
 32             pool.SetServers(serverlist);
 33             pool.Initialize();
 34
 35             //初始化
 36             _client = new MemcachedClient();
 37             _client.PoolName = "First";
 38             _client.EnableCompression = false;
 39         }
 40
 41         #region Add
 42         public static bool Add(string key, object value)
 43         {
 44             DateTime m_expiryTime = DateTime.Now.AddMilliseconds(DefaultCacheTime);
 45             return _client.Add(key, value, m_expiryTime);
 46         }
 47         public static bool Add(string key, object value, DateTime expiry)
 48         {
 49             return _client.Add(key, value, expiry);
 50         }
 51         public static bool Add(string key, object value, int hashCode)
 52         {
 53             return _client.Add(key, value, hashCode);
 54         }
 55         public static bool Add(string key, object value, DateTime expiry, int hashCode)
 56         {
 57             return _client.Add(key, value, expiry, hashCode);
 58         }
 59         #endregion
 60
 61         #region Delete
 62         /// <summary>删除缓存</summary>
 63         /// <param name="key"></param>
 64         /// <returns></returns>
 65         public static bool Delete(string key)
 66         {
 67             return _client.Delete(key);
 68         }
 69
 70         /// <summary>删除缓存</summary>
 71         /// <param name="key"></param>
 72         /// <param name="expiry"></param>
 73         /// <returns></returns>
 74         public static bool Delete(string key, DateTime expiry)
 75         {
 76             return _client.Delete(key, expiry);
 77         }
 78
 79         /// <summary>删除缓存</summary>
 80         /// <param name="key"></param>
 81         /// <param name="hashCode"></param>
 82         /// <param name="expiry"></param>
 83         /// <returns></returns>
 84         public static bool Delete(string key, object hashCode, DateTime expiry)
 85         {
 86             return _client.Delete(key, hashCode, expiry);
 87         }
 88
 89         #endregion
 90
 91         #region Get
 92         /// <summary>获取缓存</summary>
 93         /// <param name="key"></param>
 94         /// <returns></returns>
 95         public static object Get(string key)
 96         {
 97             return _client.Get(key);
 98         }
 99         /// <summary>获取缓存</summary>
100         /// <param name="key"></param>
101         /// <param name="hashCode"></param>
102         /// <returns></returns>
103         public static object Get(string key, int hashCode)
104         {
105             return _client.Get(key, hashCode);
106         }
107         /// <summary>获取缓存</summary>
108         /// <param name="key"></param>
109         /// <param name="hashCode"></param>
110         /// <param name="asString"></param>
111         /// <returns></returns>
112         public static object Get(string key, object hashCode, bool asString)
113         {
114             return _client.Get(key, hashCode, asString);
115         }
116         #endregion
117
118         #region Replace
119         /// <summary>
120         /// 替换更新
121         /// </summary>
122         /// <param name="key"></param>
123         /// <param name="value"></param>
124         /// <returns></returns>
125         public static bool Replace(string key, object value)
126         {
127             return _client.Replace(key, value);
128         }
129         /// <summary>
130         /// 替换更新
131         /// </summary>
132         /// <param name="key"></param>
133         /// <param name="value"></param>
134         /// <param name="expiry"></param>
135         /// <returns></returns>
136         public static bool Replace(string key, object value, DateTime expiry)
137         {
138             return _client.Replace(key, value, expiry);
139         }
140         /// <summary>
141         /// 替换更新
142         /// </summary>
143         /// <param name="key"></param>
144         /// <param name="value"></param>
145         /// <param name="hashCode"></param>
146         /// <returns></returns>
147         public static bool Replace(string key, object value, int hashCode)
148         {
149             return _client.Replace(key, value, hashCode);
150         }
151         /// <summary>
152         /// 替换更新
153         /// </summary>
154         /// <param name="key"></param>
155         /// <param name="value"></param>
156         /// <param name="expiry"></param>
157         /// <param name="hashCode"></param>
158         /// <returns></returns>
159         public static bool Replace(string key, object value, DateTime expiry, int hashCode)
160         {
161             return _client.Replace(key, value, expiry, hashCode);
162         }
163         #endregion
164
165         #region Set
166         public static bool Set(string key, object value)
167         {
168             return _client.Set(key, value);
169         }
170         public static bool Set(string key, object value, DateTime expiry)
171         {
172             return _client.Set(key, value, expiry);
173         }
174         public static bool Set(string key, object value, int hashCode)
175         {
176             return _client.Set(key, value, hashCode);
177         }
178         public static bool Set(string key, object value, DateTime expiry, int hashCode)
179         {
180             return _client.Set(key, value, expiry, hashCode);
181         }
182         #endregion
183
184         #region Stats
185         public static Hashtable Stats()
186         {
187             return _client.Stats();
188         }
189
190         public static Hashtable Stats(ArrayList servers)
191         {
192             return _client.Stats(servers);
193         }
194         #endregion
195
196         /// <summary>判断指定Key的缓存是否存在</summary>
197         /// <param name="key"></param>
198         /// <returns></returns>
199         public static bool KeyExists(string key)
200         {
201             return _client.KeyExists(key);
202         }
203
204         /// <summary>
205         /// 移除缓存,针对空间
206         /// </summary>
207         /// <param name="key"></param>
208         public static void RemoveRegionCache(string regionName)
209         {
210
211         }
212     }
213 }

MemcachHelper

时间: 2024-10-08 07:13:32

Memcached缓存帮助类的相关文章

Java MemCached 缓存实现

首先创建MemCached 缓存管理类,此代码测试需要添加 java_memcached-release_2.6.3.jar,commons-pool-1.5.6.jar,slf4j-api-1.6.1.jar,slf4j-simple-1.6.1.jar 这几个jar包 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

利用Spring.Net技术打造可切换的分布式缓存读写类

利用Spring.Net技术打造可切换的Memcached分布式缓存读写类 Memcached是一个高性能的分布式内存对象缓存系统,因为工作在内存,读写速率比数据库高的不是一般的多,和Radis一样具有高效的读写和分布式的优势,上一篇博文<Memcached在Windows下的配置和使用>已经对介绍过它在windows上的配置和使用. 新建ICacheWriter类--CacheWriter的接口,以达到通过配置文件可以切换缓存读写方式,例如,缓存读写也可以通过httpruntime.cach

Memcached缓存框架的使用

Memcach什么是Memcache 什么是Memcache? Memcache是一个高性能的分布式的内存对象缓存系统,通过在内存里维护一个统一的巨大的hash表,它能够用来存储各种格式的数据,包括图像.视频.文件以及数据库检索的结果等.简单的说就是将数据调用到内存中,然后从内存中读取,从而大大提高读取速度.Memcached是一个高并发的内存键值对缓存系统,它的主要作用是将数据库查询结果,内容,以及其它一些耗时的计算结果缓存到系统内存中,从而加速Web应用程序的响应速度. Memcache和m

memcached学习笔记5--socke操作memcached 缓存系统

使用条件:当我们没有权限或者不能使用服务器的时候,我们需要用socket操作memcached memcached-client操作 特点: 无需开启memcache扩展 使用fsocketopen()套接字连接memcached 同样执行CRUD require_once(CLASS_PATH.'memcached-client.php');//CLASS_PATH 是我定义的类文件文件夹路径 $mc = new memcached( array( 'servers' => array( '1

受教了,memcache比较全面点的介绍,受益匪浅,适用memcached的业务场景有哪些?memcached的cache机制是怎样的?在设计应用时,可以通过Memcached缓存那些内容?

基本问题 1.memcached的基本设置 1)启动Memcache的服务器端 # /usr/local/bin/memcached -d -m 10 -u root -l 192.168.0.200 -p 12000 -c 256 -P /tmp/memcached.pid -d选项是启动一个守护进程, -m是分配给Memcache使用的内存数量,单位是MB,我这里是10MB, -u是运行Memcache的用户,我这里是root, -l是监听的服务器IP地址,如果有多个地址的话,我这里指定了服

缓存处理类(MemoryCache结合文件缓存)

想提升站点的性能,于是增加了缓存,但是站点不会太大,于是不会到分布式memcached的缓存和redis这个nosql库,于是自己封装了.NET内置的缓存组件 原先使用System.Web.Caching.Cache,但是asp.net会在System.Web.Caching.Cache缓存页面等数据,于是替换了System.Web.Caching.Cache为MemoryCache. 而在使用MemoryCache的时候,重新启动网站会丢失缓存,于是加了自己的扩展,将缓存序列化存放在文件内,在

memcached缓存服务器介绍及其安装过程

Memcache是什么? memcached是以LiveJournal旗下Danga Interactive 公司的Brad Fitzpatric 为首开发的一款软件.现在 已成为mixi.hatena.Facebook.Vox.LiveJournal等众多服务中提高Web应用扩展性的重要因素. Memcached是一款开源.高性能.分布式内存对象缓存系统,可应用各种需要缓存的场景,其主要目的是通过降低对Database的访问来加速web应用程序.许多Web应用都将数据保存到RDBMS中,应用服

Memcached缓存实例

1.引用dll:Enyim.MemCaching.dll(网上可以下载到) 2.配置web.config: 3.创建Memcached缓存类MemCacheHelper 4.调用:

NGINX负载均衡-memcached缓存服务

实验环境: NGINX                         CentOS 7.2x86_64            IP:172.16.253.94    192.168.1.10 RealServer1                 CentOS 6.7x86_64            IP:192.168.1.20 RealServer2                 CentOS 7.2x86_64            IP:192.168.1.30 client