/// <summary>
/// 删除指定缓存
/// </summary>
/// <param name="key"></param>
public static void RemoveCache(string key)
{
if (mclient.KeyExists(key))
{
mclient.Delete(key);
}
}
static void Main(string[] args)
{
//就是构建了一个集群 安装memcached 的使用 我们是一个客户端使用
//在实际项目中使用 可以在哪些地方使用 有一个唯一的KeyValue 来获取一个单独的数据
//项目中玩耍的东西。。
string[] serverlist = { "127.0.0.1:11211", "10.0.0.132:11211" };
//初始化池
SockIOPool pool = SockIOPool.GetInstance();
pool.SetServers(serverlist);
pool.InitConnections = 3;
pool.MinConnections = 3;
pool.MaxConnections = 5;
pool.SocketConnectTimeout = 1000;
pool.SocketTimeout = 3000;
pool.MaintenanceSleep = 30;
pool.Failover = true;
pool.Nagle = false;
pool.Initialize();
// 获得客户端实例
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;
Console.WriteLine("------------测 试-----------");
mc.Set("test", "my value"); //存储数据到缓存服务器，这里将字符串"my value"缓存，key 是"test"
if (mc.KeyExists("test")) //测试缓存存在key为test的项目
{
Console.WriteLine("test is Exists");
Console.WriteLine(mc.Get("test").ToString()); //在缓存中获取key为test的项目
}
else
{
Console.WriteLine("test not Exists");
}
Console.ReadLine();
mc.Delete("test"); //移除缓存中key为test的项目
if (mc.KeyExists("test"))
{
Console.WriteLine("test is Exists");
Console.WriteLine(mc.Get("test").ToString());
}
else
{
Console.WriteLine("test not Exists");
}
Console.ReadLine();
SockIOPool.GetInstance().Shutdown(); //关闭池， 关闭sockets
}
static void Main(string[] args)
{
string[] serverList = { "192.168.1.120:11211", "10.0.0.137:11211" };
//初始化池
SockIOPool pool = SockIOPool.GetInstance();
pool.SetServers(serverList);
pool.InitConnections = 3;
pool.MinConnections = 3;
pool.MaxConnections = 5;
pool.SocketConnectTimeout = 1000;
pool.SocketTimeout = 3000;
pool.MaintenanceSleep = 30;
pool.Failover = true;
pool.Nagle = false;
pool.Initialize();
//获得客户端实例
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;
Console.WriteLine("------------测 试-----------");
string key = "test";
mc.Set(key, "my value"); //存储数据到缓存服务器，这里将字符串"my value"缓存，key 是"test"
if (mc.KeyExists(key))
{
Console.WriteLine("test is Exists");
Console.WriteLine(mc.Get("test").ToString()); //在缓存中获取key为test的项目
}
else
{
Console.WriteLine("test not Exists");
}
Console.ReadLine();
//移除缓存中key为test的项目
mc.Delete(key);
if (mc.KeyExists(key))
{
Console.WriteLine("test is Exists");
Console.WriteLine(mc.Get("test").ToString());
}
else
{
Console.WriteLine("test not Exists");
}
Console.ReadLine();
//关闭池， 关闭sockets
SockIOPool.GetInstance().Shutdown();
}
public static bool Delete(string key)
{
if (mc.KeyExists(key))
{
return(mc.Delete(key));
}
return(false);
}
/// <summary>
/// 添加缓存信息(如果存在缓存信息则直接重写设置，否则添加)
/// 使用：MemcacheHelper.GetInstance().Add(key,value)
/// </summary>
/// <param name="key">需要缓存的键</param>
/// <param name="value">需要缓存的值</param>
public void Add(string key, object value)
{
if (_client.KeyExists(key))
{
_client.Set(key, value);
}
_client.Add(key, value);
}
public object Get(string key)
{
if (mCacheClient.KeyExists(key))
{
return(mCacheClient.Get(key));
}
return(null);
}
/// <summary>
/// 取值泛型
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static T Get <T>(string key)
{
if (mc.KeyExists(key))
{
return((T)mc.Get(key));
}
else
{
return(default(T));
}
}
/// <summary>
/// 缓存是否存在
/// </summary>
/// <param name="key">键</param>
/// <returns></returns>
public static bool CacheIsExists(string key)
{
if (mc.KeyExists(key))
{
return true;
}
else
{
return false;
}
}
public void Add(string key, object value, DateTime expireDate)
{
if (mc.KeyExists(key))
{
mc.Set(key, value, expireDate);
}
else
{
mc.Add(key, value, expireDate);
}
}
//查询
protected void Button2_Click(object sender, EventArgs e)
{
GetDb(out MemcachedClient MClient);
if (MClient.KeyExists("key1"))
{
Response.Write(MClient.Get("key1"));
}
else
{
Response.Write("<script>alert('查询失败!')</script>");
}
}
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));
}
}
public T Get <T>(string key, Func <T> acquire)
{
key = preFix + key;
if (mc.KeyExists(key))
{
return(_Get <T>(key));
}
else
{
T result = acquire();
_Set(key, result);
return(result);
}
}
public void TestDelete()
{
//Test Delete
MemcachedClient mc = new MemcachedClient();
if (mc.KeyExists("SetTest"))
{
mc.Delete("SetTest", null, DateTime.MaxValue);
if (!mc.KeyExists("SetTest"))
{
HandleLogs("[Cmd=Delete]Key为SetTest的值已经被删除");
}
}
}
private void button1_Click(object sender, EventArgs e)
{
string[] serverlist = { "127.0.0.1:11211", "172.0.0.1:11211" };
//初始化池
SockIOPool pool = SockIOPool.GetInstance();
pool.SetServers(serverlist);
pool.InitConnections = 3;
pool.MinConnections = 3;
pool.MaxConnections = 5;
pool.SocketConnectTimeout = 1000;
pool.SocketTimeout = 3000;
pool.MaintenanceSleep = 30;
pool.Failover = true;
pool.Nagle = false;
pool.Initialize();
// 获得客户端实例
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;
Console.WriteLine("------------测 试-----------");
mc.Set("test", "my value"); //存储数据到缓存服务器，这里将字符串"my value"缓存，key 是"test"
if (mc.KeyExists("test")) //测试缓存存在key为test的项目
{
Console.WriteLine("test is Exists");
Console.WriteLine(mc.Get("test").ToString()); //在缓存中获取key为test的项目
}
else
{
Console.WriteLine("test not Exists");
}
Console.ReadLine();
mc.Delete("test"); //移除缓存中key为test的项目
if (mc.KeyExists("test"))
{
Console.WriteLine("test is Exists");
Console.WriteLine(mc.Get("test").ToString());
}
else
{
Console.WriteLine("test not Exists");
}
Console.ReadLine();
SockIOPool.GetInstance().Shutdown(); //关闭池， 关闭sockets
}
static void Main(string[] args)
{
string[] serverList = { "192.168.199.130:11211" };
//创建一个Memcache连接池
SockIOPool sockPool = SockIOPool.GetInstance("MemcachedPool");
//Set Memcache Server List
sockPool.SetServers(serverList);
// Set Servers Initial Connections Number
sockPool.InitConnections = 3;
sockPool.MinConnections = 3;
sockPool.MaxConnections = 5;
//Set TimeOut of Connection
sockPool.SocketConnectTimeout = 1000;
//Set TimeOut of Reads
sockPool.SocketTimeout = 3000;
sockPool.MaintenanceSleep = 30;
sockPool.Failover = true;
sockPool.Nagle = false;
sockPool.Initialize();
MemcachedClient mClient = new MemcachedClient();
mClient.EnableCompression = false;
mClient.PoolName = "MemcachedPool";
mClient.Set("key", "value");
if (!mClient.KeyExists("key"))
{
Console.WriteLine("不存在该key");
}
else
{
Console.WriteLine(mClient.Get("key").ToString());
mClient.Delete("key");
if (!mClient.KeyExists("key"))
{
Console.WriteLine("不存在该key");
}
else
{
Console.WriteLine(mClient.Get("key").ToString());
}
}
SockIOPool.GetInstance("MemcachedPool").Shutdown();
}
/// <summary>
/// Determines if the givenn key is present in cache for the current object.
/// </summary>
/// <param name = "data"></param>
/// <param name = "key"></param>
/// <returns></returns>
public static Boolean KeyExists(this IDataIdentify data, String key)
{
try
{
var translateKey = data.TranslateKey(key);
return(DefaultCache.KeyExists(translateKey));
}
catch (Exception e)
{
STrace.Exception(typeof(LogicCache).FullName, e);
return(false);
}
}
static void Main(string[] args)
{
string[] servidores = { "127.0.0.1:11211" };
SockIOPool pool = SockIOPool.GetInstance();
pool.SetServers(servidores);
pool.Initialize();
var cache = new MemcachedClient();
string chave = "dados";
string retorno = "";
if (cache.KeyExists(chave))
{
retorno = cache.Get(chave).ToString();
}
else
{
cache.Set(chave, DateTime.Now.ToString(), DateTime.Now.AddMinutes(1));
retorno = "primeiro acesso ao cache";
}
Console.WriteLine(retorno);
Console.Read();
}
public static void MemCache()
{
InitMemcache();
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;
DisplayMenu();
while (true)
{
string selected = Console.ReadLine();
switch (selected)
{
case "1":
mc.Set("test", "my value");
break;
case "2":
if (mc.KeyExists("test"))
{
Console.WriteLine(mc.Get("test").ToString());
}
else
{
Console.WriteLine("it not exists test");
}
break;
default:
break;
}
}
}
//更多的是存储一个自定义的类的实例对象。这就需要使用到序列化，下面我们来新加一个类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();
}
public static bool Delete(string key)
{
if (mc.KeyExists(key))
{
mc.Delete(key);
}
return(true);
}
public void Remove(string key)
{
var thiskey = getKey(key);
if (mc.KeyExists(thiskey))
{
mc.Delete(thiskey);
}
}
/// <summary>
/// 判断pkey关键字是否在Pmc中
/// </summary>
/// <param name="pMC"></param>
/// <param name="pKey"></param>
/// <returns></returns>
public static bool IsCache(string pKey)
{
if (MemcacheHelperInit())
{
if (mc.KeyExists(pKey))
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
/// <summary>
/// Determines whether an object with the given key exists in the cache.
/// </summary>
/// <param name="key">The key of the object.</param>
/// <returns>True if the key exists in the cache, false otherwise.</returns>
public bool Contains(object key)
{
if (key == null)
{
return(false);
}
return(_client.KeyExists(GetCacheKey(key)));
}
internal static void SetValue(string sessionId, string userName, DateTime dateTime)
{
MemcachedClient _mc = GetClient();
if (_mc.KeyExists(sessionId))
{
_mc.Delete(sessionId);
}
_mc.Add(sessionId, userName, dateTime);
}
/// <summary>
/// 删除
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static bool Delete(string key)
{
bool isOK = false;
if (m_memcachedClient.KeyExists(key))
{
isOK = m_memcachedClient.Delete(key);
}
return(isOK);
}
/// <summary>
/// 缓存是否存在
/// </summary>
/// <param name="pMC"></param>
/// <param name="pKey"></param>
/// <returns></returns>
private static bool IsCache(MemcachedClient pMC, string pKey)
{
if (pMC.KeyExists(pKey))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// 清除缓存
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static bool DeleteMemcached(string key)
{
if (mc.KeyExists(key))
{
return(mc.Delete(key));
}
else
{
return(false);
}
}
public void TestSet()
{
MemcachedClient mc = new MemcachedClient();
mc.EnableCompression = false;
mc.Add("SetTest", "123");
//Test Set
mc.Set("SetTest", "public bool Set(string key, object value, DateTime expiry, int hashCode)");
if (mc.KeyExists("SetTest"))
{
HandleLogs("[Cmd=Set]SetTest的值是：" + mc.Get("SetTest").ToString());
}
}
public void TestGet()
{
MemcachedClient mc = new MemcachedClient();
mc.Add("Get", "Get A Cmd=Get");
if (mc.KeyExists("Get"))
{
Object o = mc.Get("Get");
if (o != null)
{
HandleLogs("[Cmd=Get]Get的值是：" + o.ToString());
mc.Delete("Get");
}
}
}
public override string Get(PrimaryKeyEntity entity)
{
MemcachedClient client = new MemcachedClient();
if (client.KeyExists(entity.Prefix))
{
long id = client.Increment(entity.Prefix, 1);
return(string.Format("{0}{1}",
entity.IsMustPrefix ? entity.Prefix : string.Empty,
entity.IsMustFillWithChar ? id.ToString().PadLeft(entity.NumberLength, entity.FillChar) : id.ToString()));
}
else
{
return(string.Empty);
}
}
