设为首页 收藏本站

运维网

 找回密码
 立即注册
查看: 1567|回复: 0

[经验分享] C#实现Memcached分布式缓存，指定服务器保存变量

[复制链接]
lee_hirisun
累计签到：6 天
连续签到：1 天
发表于 2015-8-31 11:31:38 | 显示全部楼层 |阅读模式
　　说明：Memcached 分为服务器端和客户端， 客户端有多种实现方式，我这里是选择了这个版本 http://sourceforge.net/projects/memcacheddotnet/?source=dlp
　　第 1 步： 配置环境
　　1.下载服务器memcached for win32安装。http://www.splinedancer.com/memcached-win32/，www.splinedancer.com/memcached-win32/memcached-1.2.4-Win32-Preview-20080309_bin.zip
　　我在源码文件  服务器设置  里面附带了memcached.exe，把memcached.exe这个文件拷贝到C盘新建 文件夹 C:\memcached-1.2.6
　　2.用管理员方式开口cmd命令窗口 输入： cd C:\memcached-1.2.6 然后输入memcached.exe -d install 就可以把memcached安装为windows服务了。
　　3.启动服务后，memcached服务默认占用的端口是11211，占用的最大内存默认是64M。
　　4.可以自己修改端口号，但是需要修改注册表
　　打开注册表，找到：
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\memcached Server
其中的ImagePath项的值为："c:\memcached-1.2.6\memcached.exe" -d runservice
　　改成："c:\memcached-1.2.6\memcached.exe" -p 12345 -m 1024 -d runservice
表示可以 缓存 1G数据。端口 12345
　　第 2 步： 打开Visual Studio 2010  ，新建项目www.memcached.com,这步我就省略了。
　　第 3步：  添加缓存帮组文件



using System;
using System.Web;
using System.Linq;
using System.Collections;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.Configuration;
using Memcached.ClientLibrary;
namespace www.memcached.com
{
/// <summary>
/// 页 面 名：缓存管理类<br/>
/// 说    明：设置、获取、移除Cache<br/>
/// 作    者：xxx<br/>
/// 时    间：2012-12-12(神奇的数字,传说中的12K)<br/>
/// 修 改 者：<br/>
/// 修改时间：<br/>
/// </summary>
public class CacheHelper
{
#region 变量和构造函数
//缓存服务器地址和端口,这样就实现了分布式缓存。服务器可以多个，用Socket读写数据"127.0.0.1:12345",
private static Dictionary<string, string> Servers = new Dictionary<string, string>();
static MemcachedClient mc = null;
//服务器缓存
static Dictionary<string, SockIOPool> Servers1 = new Dictionary<string, SockIOPool>();
static object LOCK_OBJECT = new object();//安全锁定
/// <summary>
/// 静态构造函数
/// </summary>
static CacheHelper()
{
InitServer();
List<string> keys = Servers.Keys.ToList<string>();
foreach (var k in Servers.Keys)
{
SockIOPool pool = SockIOPool.GetInstance(k);
string[] s = new string[] { Servers[k] };
pool.SetServers(s);//设置服务器
pool.MaxConnections = 10000;
pool.MinConnections = 10;
pool.SocketConnectTimeout = 1000;
pool.SocketTimeout = 100;
pool.Initialize();//初始化缓存线程池
            }
//默认池
List<string> defaultServerList=new  List<string>();
foreach (var k in Servers.Keys) defaultServerList.Add(Servers[k]);
SockIOPool defaultPool = SockIOPool.GetInstance("DefaultPool");
defaultPool.SetServers(defaultServerList.ToArray());//设置服务器
defaultPool.MaxConnections = 10000;
defaultPool.MinConnections = 10;
defaultPool.SocketConnectTimeout = 1000;
defaultPool.SocketTimeout = 100;
defaultPool.Initialize(); //初始化默认线程池
mc = new MemcachedClient();
mc.PoolName = "DefaultPool";
}
/// <summary>
/// 初始化服务器列表，这里默认两台服务器.
/// </summary>
static void InitServer(){
//这里可以写复杂灵活点，动态从配置文件获取，我这里固定了两个
Servers.Add("Svr1", ConfigurationManager.AppSettings["Svr1"]);
Servers.Add("Svr2", ConfigurationManager.AppSettings["Svr2"]);
}
private CacheHelper() { }
#endregion
#region 获取客户端
public static MemcachedClient GetClient(string server)
{
MemcachedClient current = Singleton<MemcachedClient>.Instance;
current.PoolName = server;
return current;
}
#endregion
#region 默认

#region 写(Set)
/// <summary>
/// 设置数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
public static void Set(string key, object value)
{
mc.Set(key, value);
}
/// <summary>
/// 设置数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="hashCode">哈希码</param>
public static void Set(string key, object value, int hashCode)
{
mc.Set(key, value, hashCode);
}
/// <summary>
/// 设置数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
public static void Set(string key, object value, DateTime expiry)
{
mc.Set(key, value, expiry);
}
/// <summary>
/// 设置数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
public static void Set(string key, object value, DateTime expiry, int hashCode)
{
mc.Set(key, value, expiry, hashCode);
}
#endregion
#region 读(Get)
#region 返回泛型
/// <summary>
/// 读取数据缓存
/// </summary>
/// <param name="key">键</param>
public static T Get<T>(string key)
{
return (T)mc.Get(key);
}
/// <summary>
/// 读取数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="hashCode">哈希码</param>
public static T Get<T>(string key, int hashCode)
{
return (T)mc.Get(key, hashCode);
}
/// <summary>
/// 读取数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="asString">是否把值作为字符串返回</param>
public static T Get<T>(string key, object value, bool asString)
{
return (T)mc.Get(key, value, asString);
}
#endregion
/// <summary>
/// 读取数据缓存
/// </summary>
/// <param name="key">键</param>
public static object Get(string key)
{
return mc.Get(key);
}
/// <summary>
/// 读取数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="hashCode">哈希码</param>
public static object Get(string key, int hashCode)
{
return mc.Get(key, hashCode);
}
/// <summary>
/// 读取数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="asString">是否把值作为字符串返回</param>
public static object Get(string key, object value, bool asString)
{
return mc.Get(key, value, asString);
}
#endregion
#region 批量写(Set)
/// <summary>
/// 批量设置数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
public static void SetMultiple(string[] keys, object[] values)
{
for (int i = 0; i < keys.Length; i++)
{
mc.Set(keys, values);
}
}
/// <summary>
/// 批量设置数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="hashCode">哈希码</param>
public static void SetMultiple(string[] keys, object[] values, int[] hashCodes)
{
for (int i = 0; i < keys.Length; i++)
{
mc.Set(keys, values, hashCodes);
}
}
/// <summary>
/// 批量设置数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
public static void SetMultiple(string[] keys, object[] values, DateTime[] expirys)
{
for (int i = 0; i < keys.Length; i++)
{
mc.Set(keys, values, expirys);
}
}
/// <summary>
/// 批量设置数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
public static void Set(string[] keys, object[] values, DateTime[] expirys, int[] hashCodes)
{
for (int i = 0; i < keys.Length; i++)
{
mc.Set(keys, values, expirys, hashCodes);
}
}
#endregion
#region 批量读取(Multiple),返回哈希表 Hashtable
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
public static Hashtable GetMultiple(string[] keys)
{
return mc.GetMultiple(keys);
}
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
/// <param name="hashCodes">哈希码集合</param>
public static Hashtable GetMultiple(string[] keys, int[] hashCodes)
{
return mc.GetMultiple(keys, hashCodes);
}
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
/// <param name="hashCodes">哈希码集合</param>
/// <param name="asString">所有值返回字符</param>
public static Hashtable GetMultiple(string[] keys, int[] hashCodes, bool asString)
{
return mc.GetMultiple(keys, hashCodes, asString);
}
#endregion
#region 批量读取(Multiple),返回对象数组object[]
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
public static object[] GetMultipleArray(string[] keys)
{
return mc.GetMultipleArray(keys);
}
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
/// <param name="hashCodes">哈希码集合</param>
public static object[] GetMultipleArray(string[] keys, int[] hashCodes)
{
return mc.GetMultipleArray(keys, hashCodes);
}
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
/// <param name="hashCodes">哈希码集合</param>
/// <param name="asString">所有值返回字符</param>
public static object[] GetMultipleArray(string[] keys, int[] hashCodes, bool asString)
{
return mc.GetMultipleArray(keys, hashCodes, asString);
}
#endregion
#region 批量读取(Multiple),返回泛型集合List[T]
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
public static List<T> GetMultipleList<T>(string[] keys)
{
object[] obj = mc.GetMultipleArray(keys);
List<T> list = new List<T>();
foreach (object o in obj)
{
list.Add((T)o);
}
return list;
}
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
/// <param name="hashCodes">哈希码集合</param>
public static List<T> GetMultipleList<T>(string[] keys, int[] hashCodes)
{
object[] obj = mc.GetMultipleArray(keys, hashCodes);
List<T> list = new List<T>();
foreach (object o in obj)
{
list.Add((T)o);
}
return list;
}
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
/// <param name="hashCodes">哈希码集合</param>
/// <param name="asString">所有值返回字符</param>
public static List<T> GetMultipleList<T>(string[] keys, int[] hashCodes, bool asString)
{
object[] obj = mc.GetMultipleArray(keys, hashCodes, asString);
List<T> list = new List<T>();
foreach (object o in obj)
{
list.Add((T)o);
}
return list;
}
#endregion
#region 替换更新(Replace)
/// <summary>
/// 替换更新数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
public static void Replace(string key, object value)
{
mc.Replace(key, value);
}
/// <summary>
/// 替换更新数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="hashCode">哈希码</param>
public static void Replace(string key, object value, int hashCode)
{
mc.Replace(key, value, hashCode);
}
/// <summary>
/// 替换更新数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
public static void Replace(string key, object value, DateTime expiry)
{
mc.Replace(key, value, expiry);
}
/// <summary>
/// 替换更新数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
public static void Replace(string key, object value, DateTime expiry, int hashCode)
{
mc.Replace(key, value, expiry, hashCode);
}
#endregion
#region 删除(Delete)
/// <summary>
///删除指定条件缓存
/// </summary>
/// <param name="key">键</param>
public static bool Delete(string key)
{
return mc.Delete(key);
}
/// <summary>
/// 删除指定条件缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="hashCode">哈希码</param>
/// <param name="expiry">过期时间</param>
public static bool Delete(string key, int hashCode, DateTime expiry)
{
return mc.Delete(key, hashCode, expiry);
}
/// <summary>
/// 删除指定条件缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="expiry">过期时间</param>
public static bool Delete(string key, DateTime expiry)
{
return mc.Delete(key, expiry);
}
/// <summary>
/// 移除全部缓存
/// </summary>
public static void RemovAllCache()
{
mc.FlushAll();
}
/// <summary>
/// 移除全部缓存
/// </summary>
/// <param name="list">移除指定服务器缓存</param>
public static void RemovAllCache(ArrayList list)
{
mc.FlushAll(list);
}
#endregion
#region 是否存在(Exists)
/// <summary>
/// 判断指定键的缓存是否存在
/// </summary>
/// <param name="key">键</param>
/// <returns></returns>
public static bool IsExists(string key)
{
return mc.KeyExists(key);
}
#endregion
#region 数值增减
#region 存储一个数值元素
/// <summary>
/// 存储一个数值元素
/// </summary>
/// <param name="key">键</param>
/// <returns></returns>
public static bool StoreCounter(string key, long counter)
{
return mc.StoreCounter(key, counter);
}
/// <summary>
///  存储一个数值元素
/// </summary>
/// <param name="key">键</param>
/// <param name="inc">增长幅度</param>
/// <param name="hashCode">哈希码</param>
/// <returns></returns>
public static bool StoreCounter(string key, long counter, int hashCode)
{
return mc.StoreCounter(key, counter, hashCode);
}
#endregion
#region 获取一个数值元素
/// <summary>
/// 获取一个数值元素
/// </summary>
/// <param name="key">键</param>
/// <returns></returns>
public static long GetCounter(string key)
{
return mc.GetCounter(key);
}
/// <summary>
///  获取一个数值元素
/// </summary>
/// <param name="key">键</param>
/// <param name="hashCode">哈希码</param>
/// <returns></returns>
public static long GetCounter(string key, int hashCode)
{
return mc.GetCounter(key, hashCode);
}
#endregion
#region 增加一个数值元素的值(Increment)
/// <summary>
/// 将一个数值元素增加。 如果元素的值不是数值类型，将其作为0处理
/// </summary>
/// <param name="key">键</param>
/// <returns></returns>
public static long Increment(string key)
{
return mc.Increment(key);
}
/// <summary>
///  将一个数值元素增加。 如果元素的值不是数值类型，将其作为0处理
/// </summary>
/// <param name="key">键</param>
/// <param name="inc">增长幅度</param>
/// <returns></returns>
public static long Increment(string key, long inc)
{
return mc.Increment(key, inc);
}
/// <summary>
///  将一个数值元素增加。 如果元素的值不是数值类型，将其作为0处理
/// </summary>
/// <param name="key">键</param>
/// <param name="inc">增长幅度</param>
/// <param name="hashCode">哈希码</param>
/// <returns></returns>
public static long Increment(string key, long inc, int hashCode)
{
return mc.Increment(key, inc, hashCode);
}
#endregion
#region 减小一个数值元素的值(Decrement)
/// <summary>
/// 减小一个数值元素的值，减小多少由参数offset决定。 如果元素的值不是数值，以0值对待。如果减小后的值小于0,则新的值被设置为0
/// </summary>
/// <param name="key">键</param>
/// <returns></returns>
public static long Decrement(string key)
{
return mc.Decrement(key);
}
/// <summary>
///  减小一个数值元素的值，减小多少由参数offset决定。 如果元素的值不是数值，以0值对待。如果减小后的值小于0,则新的值被设置为0
/// </summary>
/// <param name="key">键</param>
/// <param name="inc">增长幅度</param>
/// <returns></returns>
public static long Decrement(string key, long inc)
{
return mc.Decrement(key, inc);
}
/// <summary>
///  减小一个数值元素的值，减小多少由参数offset决定。 如果元素的值不是数值，以0值对待。如果减小后的值小于0,则新的值被设置为0
/// </summary>
/// <param name="key">键</param>
/// <param name="inc">增长幅度</param>
/// <param name="hashCode">哈希码</param>
/// <returns></returns>
public static long Decrement(string key, long inc, int hashCode)
{
return mc.Decrement(key, inc, hashCode);
}
#endregion
#endregion

#endregion
#region 指定服务器
#region 获取(Get)
/// <summary>
/// 从指定服务器获取
/// </summary>
/// <param name="server">服务器，Svr1，Svr2</param>
/// <param name="key">键</param>
/// <returns></returns>
public static object GetFrom(string server,string key)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.Get(key);
}
/// <summary>
/// 从指定服务器获取
/// </summary>
/// <param name="server">服务器，Svr1，Svr2</param>
/// <param name="key">键</param>
/// <param name="hashCode">哈希码</param>
public static object GetFrom(string server, string key, int hashCode)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.Get(key, hashCode);
}
/// <summary>
/// 从指定服务器获取
/// </summary>
/// <param name="server">服务器，Svr1，Svr2</param>
/// <param name="key">键</param>
/// <param name="asString">是否把值作为字符串返回</param>
public static object GetFrom(string server, string key, object value, bool asString)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.Get(key, value, asString);
}
#endregion
#region 写入(Set)
/// <summary>
///  设置数据缓存
/// </summary>
/// <param name="server">服务器，格式为Svr1，Svr2，Svr3，对应配置文件host</param>
/// <param name="key">键</param>
/// <param name="value">值</param>
public static void SetTo(string server,string key, object value)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
client.Set(key, value);
}
/// <summary>
///  设置数据缓存
/// </summary>
/// <param name="server">服务器，格式为Svr1，Svr2，Svr3，对应配置文件host</param>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="hashCode">哈希码</param>
public static void SetTo(string server, string key, object value, int hashCode)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
client.Set(key, value, hashCode);
}
/// <summary>
///  设置数据缓存
/// </summary>
/// <param name="server">服务器，格式为Svr1，Svr2，Svr3，对应配置文件host</param>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
public static void SetTo(string server, string key, object value, DateTime expiry)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
client.Set(key, value, expiry);
}
/// <summary>
///  设置数据缓存
/// </summary>
/// <param name="server">服务器，格式为Svr1，Svr2，Svr3，对应配置文件host</param>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
public static void SetTo(string server, string key, object value, DateTime expiry, int hashCode)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
client.Set(key, value, expiry, hashCode);
}
#endregion
#region 批量写(Set)
/// <summary>
/// 批量设置数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
public static void SetMultipleTo(string server, string[] keys, object[] values)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
for (int i = 0; i < keys.Length; i++)
{
client.Set(keys, values);
}
}
/// <summary>
/// 批量设置数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="hashCode">哈希码</param>
public static void SetMultipleTo(string server, string[] keys, object[] values, int[] hashCodes)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
for (int i = 0; i < keys.Length; i++)
{
client.Set(keys, values, hashCodes);
}
}
/// <summary>
/// 批量设置数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
public static void SetMultipleTo(string server, string[] keys, object[] values, DateTime[] expirys)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
for (int i = 0; i < keys.Length; i++)
{
client.Set(keys, values, expirys);
}
}
/// <summary>
/// 批量设置数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
public static void SetMultipleTo(string server, string[] keys, object[] values, DateTime[] expirys, int[] hashCodes)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
for (int i = 0; i < keys.Length; i++)
{
client.Set(keys, values, expirys, hashCodes);
}
}
#endregion
#region 批量读取(Multiple),返回哈希表 Hashtable
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
public static Hashtable GetMultipleFrom(string server,string[] keys)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.GetMultiple(keys);
}
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
/// <param name="hashCodes">哈希码集合</param>
public static Hashtable GetMultipleFrom(string server, string[] keys, int[] hashCodes)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.GetMultiple(keys, hashCodes);
}
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
/// <param name="hashCodes">哈希码集合</param>
/// <param name="asString">所有值返回字符</param>
public static Hashtable GetMultipleFrom(string server, string[] keys, int[] hashCodes, bool asString)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.GetMultiple(keys, hashCodes, asString);
}
#endregion
#region 批量读取(Multiple),返回对象数组object[]
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
public static object[] GetMultipleArrayFrom(string server, string[] keys)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.GetMultipleArray(keys);
}
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
/// <param name="hashCodes">哈希码集合</param>
public static object[] GetMultipleArrayFrom(string server, string[] keys, int[] hashCodes)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.GetMultipleArray(keys, hashCodes);
}
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
/// <param name="hashCodes">哈希码集合</param>
/// <param name="asString">所有值返回字符</param>
public static object[] GetMultipleArrayFrom(string server, string[] keys, int[] hashCodes, bool asString)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.GetMultipleArray(keys, hashCodes, asString);
}
#endregion
#region 批量读取(Multiple),返回泛型集合List[T]
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
public static List<T> GetMultipleListFrom<T>(string server, string[] keys)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
object[] obj = client.GetMultipleArray(keys);
List<T> list = new List<T>();
foreach (object o in obj)
{
list.Add((T)o);
}
return list;
}
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
/// <param name="hashCodes">哈希码集合</param>
public static List<T> GetMultipleListFrom<T>(string server, string[] keys, int[] hashCodes)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
object[] obj = client.GetMultipleArray(keys, hashCodes);
List<T> list = new List<T>();
foreach (object o in obj)
{
list.Add((T)o);
}
return list;
}
/// <summary>
/// 批量读取数据缓存
/// </summary>
/// <param name="keys">键集合</param>
/// <param name="hashCodes">哈希码集合</param>
/// <param name="asString">所有值返回字符</param>
public static List<T> GetMultipleListFrom<T>(string server, string[] keys, int[] hashCodes, bool asString)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
object[] obj = client.GetMultipleArray(keys, hashCodes, asString);
List<T> list = new List<T>();
foreach (object o in obj)
{
list.Add((T)o);
}
return list;
}
#endregion
#region 替换更新(Replace)
/// <summary>
/// 替换更新数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
public static void ReplaceFrom(string server, string key, object value)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
client.Replace(key, value);
}
/// <summary>
/// 替换更新数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="hashCode">哈希码</param>
public static void ReplaceFrom(string server, string key, object value, int hashCode)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
client.Replace(key, value, hashCode);
}
/// <summary>
/// 替换更新数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
public static void ReplaceFrom(string server, string key, object value, DateTime expiry)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
client.Replace(key, value, expiry);
}
/// <summary>
/// 替换更新数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
public static void ReplaceFrom(string server, string key, object value, DateTime expiry, int hashCode)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
client.Replace(key, value, expiry, hashCode);
}
#endregion
#region 删除(Delete)
/// <summary>
///删除指定条件缓存
/// </summary>
/// <param name="key">键</param>
public static bool DeleteFrom(string server, string key)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.Delete(key);
}
/// <summary>
/// 删除指定条件缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="hashCode">哈希码</param>
/// <param name="expiry">过期时间</param>
public static bool DeleteFrom(string server, string key, int hashCode, DateTime expiry)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.Delete(key, hashCode, expiry);
}
/// <summary>
/// 删除指定条件缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="expiry">过期时间</param>
public static bool DeleteFrom(string server, string key, DateTime expiry)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.Delete(key, expiry);
}
/// <summary>
/// 移除全部缓存
/// </summary>
public static void RemovAllCacheFrom(string server)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
client.FlushAll();
}
/// <summary>
/// 移除全部缓存
/// </summary>
/// <param name="list">移除指定服务器缓存</param>
public static void RemovAllCacheFrom(string server, ArrayList list)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
client.FlushAll(list);
}
#endregion
#region 是否存在(Exists)
/// <summary>
/// 判断指定键的缓存是否存在
/// </summary>
/// <param name="key">键</param>
/// <returns></returns>
public static bool IsExists(string server,string key)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.KeyExists(key);
}
#endregion
#region 数值增减
#region 存储一个数值元素
/// <summary>
/// 存储一个数值元素
/// </summary>
/// <param name="key">键</param>
/// <returns></returns>
public static bool StoreCounterTo(string server,string key, long counter)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.StoreCounter(key, counter);
}
/// <summary>
///  存储一个数值元素
/// </summary>
/// <param name="key">键</param>
/// <param name="inc">增长幅度</param>
/// <param name="hashCode">哈希码</param>
/// <returns></returns>
public static bool StoreCounterTo(string server, string key, long counter, int hashCode)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.StoreCounter(key, counter, hashCode);
}
#endregion
#region 获取一个数值元素
/// <summary>
/// 获取一个数值元素
/// </summary>
/// <param name="key">键</param>
/// <returns></returns>
public static long GetCounterFrom(string server, string key)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.GetCounter(key);
}
/// <summary>
///  获取一个数值元素
/// </summary>
/// <param name="key">键</param>
/// <param name="hashCode">哈希码</param>
/// <returns></returns>
public static long GetCounterFrom(string server, string key, int hashCode)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.GetCounter(key, hashCode);
}
#endregion
#region 增加一个数值元素的值(Increment)
/// <summary>
/// 将一个数值元素增加。 如果元素的值不是数值类型，将其作为0处理
/// </summary>
/// <param name="key">键</param>
/// <returns></returns>
public static long IncrementTo(string server, string key)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.Increment(key);
}
/// <summary>
///  将一个数值元素增加。 如果元素的值不是数值类型，将其作为0处理
/// </summary>
/// <param name="key">键</param>
/// <param name="inc">增长幅度</param>
/// <returns></returns>
public static long IncrementTo(string server, string key, long inc)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.Increment(key, inc);
}
/// <summary>
///  将一个数值元素增加。 如果元素的值不是数值类型，将其作为0处理
/// </summary>
/// <param name="key">键</param>
/// <param name="inc">增长幅度</param>
/// <param name="hashCode">哈希码</param>
/// <returns></returns>
public static long IncrementTo(string server, string key, long inc, int hashCode)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.Increment(key, inc, hashCode);
}
#endregion
#region 减小一个数值元素的值(Decrement)
/// <summary>
/// 减小一个数值元素的值，减小多少由参数offset决定。 如果元素的值不是数值，以0值对待。如果减小后的值小于0,则新的值被设置为0
/// </summary>
/// <param name="key">键</param>
/// <returns></returns>
public static long DecrementFrom(string server, string key)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.Decrement(key);
}
/// <summary>
///  减小一个数值元素的值，减小多少由参数offset决定。 如果元素的值不是数值，以0值对待。如果减小后的值小于0,则新的值被设置为0
/// </summary>
/// <param name="key">键</param>
/// <param name="inc">增长幅度</param>
/// <returns></returns>
public static long DecrementFrom(string server, string key, long inc)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.Decrement(key, inc);
}
/// <summary>
///  减小一个数值元素的值，减小多少由参数offset决定。 如果元素的值不是数值，以0值对待。如果减小后的值小于0,则新的值被设置为0
/// </summary>
/// <param name="key">键</param>
/// <param name="inc">增长幅度</param>
/// <param name="hashCode">哈希码</param>
/// <returns></returns>
public static long DecrementFrom(string server, string key, long inc, int hashCode)
{
MemcachedClient client = GetClient(server);
client.PoolName = server;
return client.Decrement(key, inc, hashCode);
}
#endregion
#endregion
#endregion

}

}
　　第 4步： 测试默认服务器



using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using Memcached.ClientLibrary;
namespace www.memcached.com
{
[Serializable]
class A
{
public string Name { get; set; }
}
public partial class Test : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
CacheHelper.RemovAllCache();
/*例子1  保存复杂对象*/
A[] a = new A[] { new A { Name = "刘德华" }, new A { Name = "施瓦辛格" }, new A { Name = "太上老君" } };
CacheHelper.Set("name", a, DateTime.Now.AddSeconds(10));
object c = CacheHelper.Get("name");
A[] b = (A[])c;
Response.Write(b[2].Name + "<br/>");
/*例子2  批量获取对象*/
int[] array = { 1, 2, 3, 4, 5, 6, 7 };
foreach (int i in array)
{
CacheHelper.Set("array" + i, i);
}
string[] keys = { "array1", "array2", "array3", "array4", "array5", "array6", "array7" };
object[] obj = CacheHelper.GetMultipleArray(keys);
foreach (object o in obj)
{
Response.Write(o + "<br/>");
}
/*例子3  获取泛型*/
A a3 = new A { Name = "我是对象" };
CacheHelper.Set("TType", a3);
A a4 = CacheHelper.Get<A>("TType");
Response.Write(a4.Name + "<br/>");
/*例子4  删除*/
try
{
Response.Write("删除对象TType " + CacheHelper.Delete("TType") + "<br/>");
A a5 = CacheHelper.Get<A>("TType");
Response.Write(a5.Name + "<br/>");
}
catch (Exception exe)
{
Response.Write("获取对象报错，说明对象已经删除，错误信息是：  " + exe.Message + "<br/>");
Response.Write("删除对象后，判断是否存在： CacheHelper.IsExists：  " + CacheHelper.IsExists("TType") + "<br/>");
}
/*例子5  增加,减少*/
long counter = 10;
CacheHelper.StoreCounter("number", counter);
Response.Write("number增加前是：  " + CacheHelper.GetCounter("number") + "<br/>");
CacheHelper.Increment("number");
Response.Write("对number增加后是：  " + CacheHelper.GetCounter("number") + "<br/>");
CacheHelper.Increment("number", 100);
Response.Write("对number增加100后是：  " + CacheHelper.GetCounter("number") + "<br/>");
CacheHelper.Decrement("number", 100);
Response.Write("对number减去100后是：  " + CacheHelper.GetCounter("number") + "<br/>");
/*例子6  批量读取 泛型  测试*/
A[] a6 = new A[] { new A { Name = "李嘉图" }, new A { Name = "亚当斯密" }, new A { Name = "苏格拉底" } };
string[] k6 = { "economy1", "economy2", "economy3" };
CacheHelper.SetMultiple(k6, a6);
Response.Write("下面是  泛型 批量  获取对象<br/>");
List<A> list = CacheHelper.GetMultipleList<A>(k6);
foreach (A p in list)
{
Response.Write(p.Name + "<br/>");
}
}
}
}
　　
　　第 5步： 测试指定服务器



using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace www.memcached.com
{
public partial class Test4 : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
CacheHelper.SetTo("Svr1", "Abc", "good1");
CacheHelper.SetTo("Svr2", "Abc", "good2");
Response.Write("第一台服务器："+CacheHelper.GetFrom("Svr1", "Abc")+"<br/>");
Response.Write("第二台服务器：" + CacheHelper.GetFrom("Svr2", "Abc") + "<br/>");
CacheHelper.StoreCounterTo("Svr1","Count",1);
CacheHelper.IncrementTo("Svr1", "Count", 10);
Response.Write("自增结果：" + CacheHelper.GetCounterFrom("Svr1", "Count") + "<br/>");
}
}
}
　　第 6步： 项目配置文件



<?xml version="1.0"?>
<!--
有关如何配置 ASP.NET 应用程序的详细信息，请访问
http://go.microsoft.com/fwlink/?LinkId=169433
-->
<configuration>
<appSettings>
<add key="Svr1" value="127.0.0.1:12345"/>
<add key="Svr2" value="192.168.1.26:11211"/>
</appSettings>
<system.web>
<compilation debug="true" targetFramework="4.0" />
<authentication mode="Forms">
<forms loginUrl="~/Account/Login.aspx" timeout="2880" />
</authentication>
<membership>
<providers>
<clear/>
<add name="AspNetSqlMembershipProvider" type="System.Web.Security.SqlMembershipProvider" connectionStringName="ApplicationServices"
enablePasswordRetrieval="false" enablePasswordReset="true" requiresQuestionAndAnswer="false" requiresUniqueEmail="false"
maxInvalidPasswordAttempts="5" minRequiredPasswordLength="6" minRequiredNonalphanumericCharacters="0" passwordAttemptWindow="10"
applicationName="/" />
</providers>
</membership>
<profile>
<providers>
<clear/>
<add name="AspNetSqlProfileProvider" type="System.Web.Profile.SqlProfileProvider" connectionStringName="ApplicationServices" applicationName="/"/>
</providers>
</profile>
<roleManager enabled="false">
<providers>
<clear/>
<add name="AspNetSqlRoleProvider" type="System.Web.Security.SqlRoleProvider" connectionStringName="ApplicationServices" applicationName="/" />
<add name="AspNetWindowsTokenRoleProvider" type="System.Web.Security.WindowsTokenRoleProvider" applicationName="/" />
</providers>
</roleManager>
</system.web>
<system.webServer>
<modules runAllManagedModulesForAllRequests="true"/>
</system.webServer>
</configuration>
　　
　　下面给出项目源码   下载地址  http://files.cnblogs.com/HCCZX/www.memcached.com.rar
　　
　　

运维网声明 1、欢迎大家加入本站运维交流群:群②:261659950 群⑤:202807635 群⑦870801961 群⑧679858003
2、本站所有主题由该帖子作者发表，该帖子作者与运维网享有帖子相关版权
3、所有作品的著作权均归原作者享有，请您和我们一样尊重他人的著作权等合法权益。如果您对作品感到满意，请购买正版
4、禁止制作、复制、发布和传播具有反动、淫秽、色情、暴力、凶杀等内容的信息，一经发现立即删除。若您因此触犯法律，一切后果自负，我们对此不承担任何责任
5、所有资源均系网友上传或者通过网络收集，我们仅提供一个展示、介绍、观摩学习的平台，我们不对其内容的准确性、可靠性、正当性、安全性、合法性等负责，亦不承担任何法律责任
6、所有作品仅供您个人学习、研究或欣赏，不得用于商业或者其他用途，否则，一切后果均由您自己承担，我们对此不承担任何法律责任
7、如涉及侵犯版权等问题，请您及时通知我们，我们将立即采取措施予以解决
8、联系人Email：admin@iyunv.com 网址：www.yunweiku.com

所有资源均系网友上传或者通过网络收集,我们仅提供一个展示、介绍、观摩学习的平台,我们不对其承担任何法律责任,如涉及侵犯版权等问题,请您及时通知我们,我们将立即处理,联系人Email:kefu@iyunv.com,QQ:1061981298 本贴地址：https://www.yunweiku.com/thread-106759-1-1.html 上篇帖子： Memcached常用命令及使用说明 下篇帖子： memcached 源码阅读笔记
回复

使用道具 举报

返回列表
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

扫码加入运维网微信交流群X

扫码加入运维网微信交流群

扫描二维码加入运维网微信交流群，最新一手资源尽在官方微信交流群！快快加入我们吧...

扫描微信二维码查看详情

客服 E-mail:iyunvcom@gmail.com

本站由青云提供云计算服务

运维网--中国最专业的运维工程师交流社区

豫ICP备20007574号-1 Copyright © 2012-2025

关于我们

发展历程

联系我们

关注我们

广告服务

广告案例

隐私条款

免责声明

用户登录

用户注册

版主守则

申请版主

手机版

金币获取

帮助中心

每日签到

Good Good

Study

Day Day

UP


客服E-mail:kefu@iyunv.com 客服QQ：1061981298


QQ群⑦：运维网交流群⑦ QQ群⑧：运维网交流群⑧ k8s群：运维网kubernetes交流群


提醒：禁止发布任何违反国家法律、法规的言论与图片等内容；本站内容均来自个人观点与网络等信息，非本站认同之观点.


本站大部分资源是网友从网上搜集分享而来，其版权均归原作者及其网站所有，我们尊重他人的合法权益，如有内容侵犯您的合法权益，请及时与我们联系进行核实删除！



合作伙伴: 青云cloud

快速回复 返回顶部 返回列表