/// <summary>
/// 添加缓存
/// </summary>
/// <param name="key">关键字</param>
/// <param name="value">缓存值</param>
public void Add <T>(string key, T value)
{
if (this.enable)
{
if (cache.Get(key) != null)
{
cache.Replace(key, value);
}
else
{
cache.Add(key, value);
}
}
return;
}
/// <summary>
/// 覆盖缓存
/// </summary>
/// <param name="pKey"></param>
/// <param name="pObject"></param>
/// <returns></returns>
private static bool StoreCache(string pKey, object pObject)
{
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = true;
bool _result = false;
if (IsCache(mc, pKey))
{
if (mc.Get(pKey) == null)
{
mc.Set(pKey, pObject);//缓存存在，强行覆盖
}
else
{
mc.Replace(pKey, pObject);//缓存存在，强行覆盖
}
_result = true;
}
else
{
mc.Add(pKey, pObject);//第一次加载缓存
_result = true;
}
return(_result);
}
//13.Replace test
public void ReplaceTest()
{
MemcachedClient cache = MemcachedClient.GetInstance("BeITMemcached");
cache.Replace("BeIt", "replaced");
HandleLogs("[Cmd=Replace]BeIt：" + cache.Get("BeIt").ToString());
}
//更多的是存储一个自定义的类的实例对象。这就需要使用到序列化，下面我们来新加一个类MyObject，让其作为可序列化的对象来存储进Memcached中
public void MemcachedTest(string[] args)
{
//初始化池
SockIOPool sock = SockIOPool.GetInstance();
sock.SetServers(serverlist.ToArray()); //添加服务器列表
sock.InitConnections = 3; //设置连接池初始数目
sock.MinConnections = 3; //设置最小连接数目
sock.MaxConnections = 5; //设置最大连接数目
sock.SocketConnectTimeout = 1000; //设置连接的套接字超时。
sock.SocketTimeout = 3000; //设置套接字超时读取
sock.MaintenanceSleep = 30; //设置维护线程运行的睡眠时间。如果设置为0，那么维护线程将不会启动;
//获取或设置池的故障标志。
//如果这个标志被设置为true则socket连接失败，
//将试图从另一台服务器返回一个套接字如果存在的话。
//如果设置为false，则得到一个套接字如果存在的话。否则返回NULL，如果它无法连接到请求的服务器。
sock.Failover = true; //如果为false，对所有创建的套接字关闭Nagle的算法。
sock.Nagle = false;
sock.Initialize();
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = true; //是否启用压缩数据
//mc.Set(key,val);//设置 键值
//mc.KeyExists(key) //键 是否存
//mc.Get(key) //获取 一个键值
//mc.Delete(key);// 删除 键值
Console.WriteLine("----------------------------Set-----------");
mc.Set("key1", "value1");
Console.WriteLine(mc.Get("key1"));
Console.WriteLine("---------------------------replay---------");
mc.Replace("key1", "Replay new Key1");
Console.WriteLine(mc.Get("key1"));
Console.WriteLine("---------------------------键值是否存在----");
if (mc.KeyExists("key2"))
{
Console.WriteLine("key2存在");
}
else
{
Console.WriteLine("key2不存在，设置新值");
mc.Set("key2", "New key2");
}
Console.WriteLine("-------------------------删除数据--------");
mc.Delete("key2");
Console.WriteLine("删除之后的数据: " + mc.Get("key2"));
Console.WriteLine("-------------------------数据过期--------");
mc.Add("key3", "新数据三内容", DateTime.Now.AddMilliseconds(5000));
Console.WriteLine(mc.Get("key5"));
System.Threading.Thread.Sleep(6000);
Console.WriteLine("过期: " + mc.Get("key5"));
Console.ReadLine();
}
/// <summary>
/// 设置缓存数据
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="coverType">覆盖类型</param>
public void Set(string key, object value, CoverType coverType = CoverType.set)
{
switch (coverType)
{
case CoverType.set:
_mcClient.Set(key, value);
break;
case CoverType.add:
_mcClient.Add(key, value);
break;
case CoverType.replace:
_mcClient.Replace(key, value);
break;
}
}
/// <summary>
/// 更新缓存
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
private void UpdateCache(string key, object value)
{
SockIOPool pool = GetPool();
memcache.PoolName = poolName;
memcache.EnableCompression = false;//是否压缩
memcache.Replace(key, value, DateTime.Now.AddMinutes(expires));
}
public virtual void Update(string key, object value, int seconds)
{
if (null != _client)
{
_client.Replace(key, value, DateTime.Now.AddSeconds(seconds));
}
if (null != _logger)
{
_logger.Error("the distribute client is null.");
}
}
public void Set(string key, object data, int expire)
{
string json = data.ToJsonString();
if (MemClient.KeyExists(key))
{
MemClient.Replace(key, json, DateTime.Now.AddMinutes(expire));
}
else
{
MemClient.Set(key, json, DateTime.Now.AddMinutes(expire));
}
}
//修改
protected void Button3_Click(object sender, EventArgs e)
{
GetDb(out MemcachedClient MClient);
bool s = MClient.Replace("key1", "replace你好");
if (s == true)
{
Response.Write("<script>alert('修改成功!')</script>");
Response.Write(MClient.Get("key1"));
}
else
{
Response.Write("<script>alert('修改失败!')</script>");
}
}
public void Set(string key, object obj, DateTime expiry)
{
if (mCacheClient.KeyExists(key))
{
mCacheClient.Replace(key, obj, expiry);
}
else
{
mCacheClient.Set(key, obj, expiry);
}
List <string> result = GetRelation(key);
for (int i = 0; i < result.Count; i++)
{
Delete(result[i]);
}
}
/// <summary>
/// 将数据以键值对的方式，缓存到Memcached
/// </summary>
/// <param name="key">缓存键</param>
/// <param name="obj">缓存值</param>
/// <param name="expiry">有效期（服务器当前时间+expiry）</param>
public void Store(string key, object obj, TimeSpan expiry)
{
DateTime timeout = DateTime.Now.Add(expiry);
if (Exists(key))
{
if (Get(key) == null)
{
memcachedClient.Set(key, obj, timeout);//缓存存在(且对象为null)，强行覆盖
}
else
{
memcachedClient.Replace(key, obj, timeout);//缓存存在，强行覆盖
}
}
else
{
memcachedClient.Add(key, obj, timeout);//第一次加载缓存
}
}
/// <seealso cref="Z.Caching.ICacheManager.Replace"/>
public bool Replace(string key, object value, DateTime expiry)
{
return(defaultClient.Replace(key, value, expiry));
}
public static bool LoadQueryInMemCached(MemcachedLoaderConfig Config, CachedQuery QueryToLoad, out string ErrorMessage)
{
bool LoadedQuery = false;
ErrorMessage = string.Empty;
ResponseCode response = ResponseCode.UnknownCommand;
Dictionary<string, Dictionary<string, string>> MemoryDict;
try
{
/*
* Connect to memcached server
*/
ServerConnectionCollection MemCachedServers = new ServerConnectionCollection();
/*
* Add Server from Config Settings
*/
MemCachedServers.Add(Config.MemcachedConnectionSettings.Server, port: Config.MemcachedConnectionSettings.Port);
/*
* Create the client
*/
IConnectionProvider provider = new ConnectionProvider(MemCachedServers);
MemcachedClient client = new MemcachedClient(provider);
/*
* Retrieve Query Data from MySql
*/
DataTable QueryDataTable = GetDataTable(Config.DBConnectionSettings, QueryToLoad);
/*
* Determine whether to permanently persist kvp cached object in Redis
*/
bool PersistCachedObject = (Config.MemcachedConnectionSettings.CacheObjectSeconds <= 0);
/*
* Cache each row from the data table as a JSON serialized dictionary
*/
if (QueryDataTable != null && QueryDataTable.Rows.Count > 0)
{
//Define a dictionary to store the data table to be serialized into a JSON object
MemoryDict = null;
string ErrMsg = string.Empty;
/*
* Convert DataTable / MySQL Query ResultSet in Dictionary<string,Dictionary<string,string>> object
*/
bool Success = Utils.GetQueryCacheDictionaryFromDataTable(Config.DBConnectionSettings, QueryToLoad, QueryDataTable, out MemoryDict, out ErrMsg);
/*
* Table Data Dictionary was successfully created - Cached each row in Memcached as a JSON dictionary
*/
if (Success)
{
foreach (KeyValuePair<string, Dictionary<string, string>> TableDictionaryKvp in MemoryDict)
{
string Key = TableDictionaryKvp.Key;
string JsonStoreValue = JsonConvert.SerializeObject(TableDictionaryKvp.Value, new KeyValuePairConverter());
/*
* Determine right expiration Datetime value
*/
DateTime ExpireDate = (PersistCachedObject) ? DateTime.MaxValue : DateTime.Now.AddSeconds(Config.MemcachedConnectionSettings.CacheObjectSeconds);
/*
* Load Kvp in Memcached
*/
response = client.Set(Key, JsonStoreValue, ExpireDate);
/*
* If key already exists replace it
*/
if (response == ResponseCode.KeyExists)
{
response = client.Replace(Key, JsonStoreValue, ExpireDate);
}
}
}
}
/*
* Success
*/
LoadedQuery = (response == ResponseCode.NoError);
Utils.GetEventLog().WriteEntry(string.Format("[MemcachedLoaderService.Memcached] Successfully loaded table [{0}] in the memory cache.", QueryToLoad.KeyPrefix));
}
catch (Exception ex)
{
ErrorMessage = string.Format("[MemcachedLoaderService.Memcached] Can't load query into Cache. Memcached Error Message [{0}].", ex.Message);
Utils.GetEventLog().WriteEntry(ErrorMessage);
}
/*
* Results
*/
return LoadedQuery;
}
/// <summary>
/// 更新缓存，缓存键必须已存在
/// </summary>
/// <param name="strKey">缓存键</param>
/// <param name="objValue">缓存值</param>
/// <returns></returns>
public static bool Replace(string strKey, object objValue)
{
return(cache.Replace(strKey, objValue));
}
/// <summary>
/// 修改缓存的值
/// 使用：MemcacheHelper.GetInstance().Update(key,value)
/// </summary>
/// <param name="key">需要修改的键</param>
/// <param name="value">需要修改的值</param>
public void Update(string key, object value)
{
_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);
}
public bool UpdateObject(string key, object value, DateTime dt)
{
return(mc.Replace(key, value, dt));
}
/// <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="server"></param>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expiry">过期时间</param>
/// <param name="hashCode"></param>
public static void ReplaceFrom(string server, string key, object value, DateTime expiry, int hashCode)
{
MemcachedClient client = GetClient(server);
client.Replace(key, value, expiry, hashCode);
}
/// <summary>
/// 替换更新数据缓存
/// </summary>
/// <param name="server"></param>
/// <param name="key">键</param>
/// <param name="value">值</param>
public static void ReplaceFrom(string server, string key, object value)
{
MemcachedClient client = GetClient(server);
client.Replace(key, value);
}
/// <summary>
/// 替换更新数据缓存
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
public static void Replace(string key, object value)
{
mc.Replace(key, value);
}
public bool Replace(string key, object value)
{
return(m_memcachedClientIns.Replace(key, value));
}
public bool Put(string key, object entity)
{
var cacheEntity = _Instance.Get(key);
return((cacheEntity != null) ? _Instance.Replace(key, entity) : _Instance.Add(key, entity));
}
static void Main(string[] args)
{
// Memcached服务器列表
// 如果有多台服务器，则以逗号分隔，例如："192.168.80.10:11211","192.168.80.11:11211"
string[] serverList = { "192.168.0.103:11211" };
// 初始化SocketIO池
string poolName = "MyPool";
SockIOPool sockIOPool = SockIOPool.GetInstance(poolName);
// 添加服务器列表
sockIOPool.SetServers(serverList);
// 设置连接池初始数目
sockIOPool.InitConnections = 3;
// 设置连接池最小连接数目
sockIOPool.MinConnections = 3;
// 设置连接池最大连接数目
sockIOPool.MaxConnections = 5;
// 设置连接的套接字超时时间（单位：毫秒）
sockIOPool.SocketConnectTimeout = 1000;
// 设置套接字超时时间（单位：毫秒）
sockIOPool.SocketTimeout = 3000;
// 设置维护线程运行的睡眠时间：如果设置为0，那么维护线程将不会启动
sockIOPool.MaintenanceSleep = 30;
// 设置SockIO池的故障标志
sockIOPool.Failover = true;
// 是否用nagle算法启动
sockIOPool.Nagle = false;
// 正式初始化容器
sockIOPool.Initialize();
// 获取Memcached客户端实例
MemcachedClient memClient = new MemcachedClient();
// 指定客户端访问的SockIO池
memClient.PoolName = poolName;
// 是否启用压缩数据：如果启用了压缩，数据压缩长于门槛的数据将被储存在压缩的形式
memClient.EnableCompression = false;
Console.WriteLine("----------------------------测试开始----------------------------");
// 01.简单的添加与读取操作
memClient.Set("test1", "edisonchou");
Console.WriteLine("test1:{0}", memClient.Get("test1"));
// 02.先添加后修改再读取操作
memClient.Set("test2", "jacky");
Console.WriteLine("test2:{0}", memClient.Get("test2"));
memClient.Set("test2", "edwin");
Console.WriteLine("test2:{0}", memClient.Get("test2"));
memClient.Replace("test2", "lousie");
Console.WriteLine("test2:{0}", memClient.Get("test2"));
// 03.判断Key值是否存在
if (memClient.KeyExists("test2"))
{
Console.WriteLine("Key:test2 is existed");
}
// 04.删除指定Key值的数据
memClient.Add("test3", "memcached");
Console.WriteLine("test3:{0}", memClient.Get("test3"));
memClient.Delete("test3");
if (!memClient.KeyExists("test3"))
{
Console.WriteLine("Key:test3 is not existed");
}
// 05.设置数据过期时间：5秒后过期
memClient.Add("test4", "expired", DateTime.Now.AddSeconds(5));
Console.WriteLine("test4:{0}", memClient.Get("test4"));
Console.WriteLine("Please waiting the sleeping time");
System.Threading.Thread.Sleep(6000);
if (!memClient.KeyExists("test4"))
{
Console.WriteLine("test4 is expired");
}
Console.WriteLine("----------------------------测试完成----------------------------");
// 关闭SockIO池
sockIOPool.Shutdown();
Console.ReadKey();
}
/// <summary>
/// 替换缓存
/// </summary>
/// <param name="key">The key</param>
/// <param name="value">The value</param>
/// <param name="expiredTime">The expiredTime</param>
/// <returns>
/// The Boolean
/// </returns>
/// 创建者：孟祺宙
/// 创建日期：2014/8/15 11:20
/// 修改者：
/// 修改时间：
/// ----------------------------------------------------------------------------------------
public bool Replace(string key, object value, DateTime expiredTime)
{
return(_memcachedClient.Replace(GetKey(key), value, expiredTime));
}
