public void InvalidateSets(IEnumerable <string> entitySets)
{
// Go through the list of objects in each of the sets.
foreach (var dep in entitySets)
{
_cache.Remove(dep);
}
//依赖未实现
}
/// <summary>
/// 写入缓存
/// </summary>
/// <param name="key">缓存键</param>
/// <param name="value">缓存值json格式</param>
public static bool Set(string key, string value)
{
try
{
int mb = 1024 * 1024;
//json字符串的大小小于1M的时候直接写入缓存
if (System.Text.Encoding.Default.GetByteCount(value) < mb)
{
return(Client.Store(Enyim.Caching.Memcached.StoreMode.Set, key, value));
}
else
{
//缓存大于1M，分块存储，返回结果,
int chunkSize = mb / 2;
bool flag = true;
//存缓存块对应的缓存键值
var subKeys = new List <string>();
for (int i = 0; i *chunkSize < value.Length; i++)
{
//分割字符串存到缓存的键值
string subKey = key + "_" + i;
//指定长度截取值
string subValue = (i + 1) * chunkSize < value.Length ? value.Substring(i * chunkSize, chunkSize) : value.Substring(i * chunkSize);
//分块写入缓存
if (Client.Store(Enyim.Caching.Memcached.StoreMode.Set, subKey, subValue))
{
subKeys.Add(subKey);
}
else
{
flag = false;
break;
}
}
if (!flag)
{
// 保存失败，将成功的子键缓存也清空
foreach (string subkey in subKeys)
{
Client.Remove(subkey);
}
}
else
{
//子键都保存成功，保存主键
flag = Client.Store(Enyim.Caching.Memcached.StoreMode.Set, key, subKeys);
}
return(flag);
}
}
catch (Exception ex)
{
throw new MemberExecption(ex.Message);
}
}
private void ClearCacheItem(string key)
{
var dependenciesTable = GetDependenciesTable();
if (dependenciesTable.ContainsKey(key))
{
foreach (var item in dependenciesTable[key])
{
memcachedClient.Remove(item);
}
}
memcachedClient.Remove(key);
}
public int RemoveResource(string resourceUri)
{
int count = 0;
var resourceUriEntries = GetResourceUriEntries(resourceUri);
foreach (var entry in resourceUriEntries)
{
var removed = _memcachedClient.Remove(entry);
if (removed)
{
count++;
}
}
return(count);
}
//删除
protected void Button9_Click(object sender, EventArgs e)
{
client.Remove("x");
client.Remove("y");
bool result = client.Remove("zz");
if (result)
{
Response.Write("<script>alert('删除成功!')</script>");
}
else
{
Response.Write("<script>alert('删除数据失败!')</script>");
}
}
/// <summary>
/// 通过key删除缓存
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public async Task <bool> DeleteAsync(string key)
{
var result = _memcachedClient.Remove(key);
if (result == false)
{
var empty = _memcachedClient.Get(key);
if (empty == null)
{
result = true;
}
}
return(await Task.FromResult(result));
}
public bool Remove(string key)
{
lock (thisLock)
{
return(client.Remove(key));
}
}
/// <summary>
/// 删除key的缓存的值
/// </summary>
/// <param name="key">key</param>
public void Remove(string key)
{
if (this.Exist(key))
{
cache.Remove(key);
}
}
public ResultDocument <T> Remove <T>(string key)
{
ResultDocument <T> resultDocument = new ResultDocument <T>
{
OperationType = ResultOperation.Delete,
StartTime = DateTime.Now,
Type = INGA.Framework.Managers.Common.Type.Cache
};
_cacheObject.Remove(key);
var itemResult = Get <T>(key);
resultDocument.EndDatime = DateTime.Now;
if (itemResult.Status == ResultStatus.Failed)
{
resultDocument.Result = default(T);
resultDocument.Status = ResultStatus.Failed;
return(resultDocument);
}
else
{
resultDocument.Result = itemResult.Result;
resultDocument.Status = ResultStatus.Success;
return(resultDocument);
}
}
/// <summary>
/// This function processes any file changes in the specified directory
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
protected object ProcessFileEvent(object obj)
{
string strFileName = (string)obj;
IMemcachedDependancy objDependancy = null;
// Lock the queue for processing
lock (_objMemDepFileLock)
{
if (this._objMemDepFile.ContainsKey(strFileName) == true)
{
objDependancy = this._objMemDepFile[strFileName];
this._objMemDepFile.Remove(strFileName);
Console.WriteLine("Item removed from Process Queue...");
}
}
if (objDependancy != null)
{
foreach (string str in objDependancy.DependancyKeys)
{
// Removing Key from memcached
_objMemcachedClient.Remove(str);
Console.WriteLine("Memcached Key {0} removed...", str);
}
}
return(null);
}
/// <summary>
/// 删除缓存
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public int Delete(string key)
{
using (MemcachedClient mc = new MemcachedClient())
{
return(mc.Remove(key) ? 1 : 0);
}
}
/// <summary>
/// 删除缓存(如果键不存在，则返回false)
/// </summary>
/// <param name="key">键</param>
/// <returns>成功:true失败:false</returns>
public static bool DelCache(string key)
{
using (MemcachedClient mc = new MemcachedClient())
{
return(mc.Remove(key));
}
}
protected override void RemoveInternal(string key)
{
if (Exists(key))
{
_cache.Remove(key);
}
}
public ActionResult DeleteItem(int idProducto, int cantidad)
{
if (!ModelState.IsValid)
{
return(View("Index"));
}
//consulto el usuario logueado
var currentUser = System.Web.HttpContext.Current.User as CustomPrincipal;
if (currentUser == null)
{
return(RedirectToAction("Index", "Account"));
}
//Configuracion del MEMCACHED client
var clientConfiguration = new MemcachedClientConfiguration {
Protocol = MemcachedProtocol.Binary
};
clientConfiguration.Servers.Add(new IPEndPoint(IPAddress.Parse("192.168.99.100"), 32768));
using (var memcachedclient = new MemcachedClient(clientConfiguration))
{
//consulto el cache del usuario logueado
var cart = memcachedclient.Get <Cart>("Cart-" + currentUser.UserName);
if (cart == null)
{
return(View("Cart"));
}
var remove = new Item();
//Consulto el item en el carrito y le resto al cantidad si llega a cero lo elimino.
foreach (var i in cart.Items.Where(i => i.Producto.id_producto == idProducto))
{
if (i.Cantidad > cantidad)
{
i.Cantidad = i.Cantidad - cantidad;
}
else
{
remove = i;
}
}
if (!remove.Equals(null))
{
cart.Items.Remove(remove);
}
if (cart.Items.Count != 0)
{
memcachedclient.Store(StoreMode.Set, "Cart-" + currentUser.UserName, cart);
}
else
{
memcachedclient.Remove("Cart-" + currentUser.UserName);
}
return(View("Cart", cart));
}
}
public void Delete(string cache_key)
{
if (Exists(cache_key))
{
cache.Remove(cache_key);
}
}
static MemcachedObjectCacheStrategy()
{
// //初始化memcache服务器池
//SockIOPool pool = SockIOPool.GetInstance();
////设置Memcache池连接点服务器端。
//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();
//cache = new MemcachedClient();
//cache.EnableCompression = false;
try
{
//config.Authentication.Type = typeof(PlainTextAuthenticator);
//config.Authentication.Parameters["userName"] = "******";
//config.Authentication.Parameters["password"] = "******";
//config.Authentication.Parameters["zone"] = "zone";//domain? ——Jeffrey 2015.10.20
DateTime dt1 = DateTime.Now;
var config = GetMemcachedClientConfiguration();
//var cache = new MemcachedClient(config);'
#if NET45 || NET461
var cache = new MemcachedClient(config);
#else
var cache = new MemcachedClient(null, config);
#endif
var testKey = Guid.NewGuid().ToString();
var testValue = Guid.NewGuid().ToString();
cache.Store(StoreMode.Set, testKey, testValue);
var storeValue = cache.Get(testKey);
if (storeValue as string != testValue)
{
throw new Exception("MemcachedStrategy失效，没有计入缓存！");
}
cache.Remove(testKey);
DateTime dt2 = DateTime.Now;
WeixinTrace.Log(string.Format("MemcachedStrategy正常启用，启动及测试耗时：{0}ms", (dt2 - dt1).TotalMilliseconds));
}
catch (Exception ex)
{
//TODO:记录是同日志
WeixinTrace.Log(string.Format("MemcachedStrategy静态构造函数异常：{0}", ex.Message));
}
}
/// <summary>
/// Remove data from cache
/// </summary>
/// <param name="key"></param>
public override void RemoveCached(string key)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException(nameof(key));
}
_cached.Remove(key);
}
public void DeleteObjectTest()
{
MemcachedClient mc = new MemcachedClient();
mc.Remove(TestObjectKey);
Assert.IsNull(mc.Get(TestObjectKey), "Remove failed.");
}
/// <summary>
/// 删除
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static bool Delete(string key)
{
if (Exists(key))
{
return(CacheClient.Remove(key));
}
return(false);
}
/// <summary>
/// 移除缓存
/// </summary>
/// <param name="key">缓存Key</param>
/// <returns>true:删除成功； false:删除失败</returns>
public bool Remove(string key)
{
if (string.IsNullOrWhiteSpace(key))
{
return(false);
}
return(memClient.Remove(key));
}
/// <inheritdoc />
public override void Remove(object key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
log.Debug("removing item {0}", key);
client.Remove(KeyAsString(key));
}
/// <summary>
/// 删除缓存(如果键不存在，则返回false)
/// </summary>
/// <param name="key">键</param>
/// <returns>成功:true失败:false</returns>
public static bool DelCache(string key)
{
if (!IsUsedCache)
{
return(false);
}
return(Mc.Remove(key));
}
public void Delete(string key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
Logger.DebugFormat("removing item {0}", key);
_client.Remove(KeyAsString(key));
}
public void Delete()
{
MemcachedClientConfiguration config = new MemcachedClientConfiguration();
config.AddServer("127.0.0.1", 11211);
config.Protocol = MemcachedProtocol.Binary;
MemcachedClient client = new MemcachedClient(config);
client.Remove("Persons");
}
public void RemoveFromCache(string key)
{
if (string.IsNullOrEmpty(key))
{
return;
}
var cacheKey = GetFinalKey(key);
_cache.Remove(cacheKey);
}
// test remove
public void RemoveTest()
{
MemcachedClient client = GetClient();
string TestObjectKey = "Hello_World";
client.Store(StoreMode.Set, TestObjectKey, "devin");
bool isRemoved = client.Remove(TestObjectKey);
HandleLogs("[Cmd=Remove]Hello_World is removed " + isRemoved);
}
public virtual void RemoveFromCache(string key, bool isFullKey = false)
{
if (string.IsNullOrEmpty(key))
{
return;
}
var cacheKey = GetFinalKey(key, isFullKey);
_cache.Remove(cacheKey);
}
/// <summary>
/// 清空Memcached缓存的区域
/// </summary>
/// <param name="regionName">Memcached缓存区域名称</param>
/// <returns>是否清空成功</returns>
public static bool ClearRegion(string regionName)
{
if (string.IsNullOrWhiteSpace(regionName))
throw new ArgumentNullException("Memcached缓存区域名称为空");
object obj = MemcachedClient.Get(regionName);
//如果Memcached缓存中获取不到region值，则说明此region下无数据，则直接返回清除成功
if (obj == null)
return true;
//清空掉Memcached缓存中的region值，如果清除老的region失败，则新的region就不写入
if (!MemcachedClient.Remove(regionName))
return false;
//设置一个新的region值到缓存中
string _version = DateTime.Now.ToString("hhmmssfff");
return MemcachedClient.Store(StoreMode.Set, regionName, _version, TimeSpan.FromDays(7));
}
public void DeleteObjectTest()
{
using (MemcachedClient client = GetClient())
{
TestData td = new TestData();
Assert.True(client.Store(StoreMode.Set, TestObjectKey, td), "Initialization failed.");
Assert.True(client.Remove(TestObjectKey), "Remove failed.");
Assert.Null(client.Get(TestObjectKey));
}
}
public override void Remove(string key, TYPE obj)
{
key = key.ToLower();
var objects = GetSharedCacheItemKeys(key);
if (objects != null)
{
objects.Remove(obj.UniqueKey);
SharedCache.Remove(obj.UniqueKey.ToString());
if (objects.Count > 0)
{
SharedCache.Store(StoreMode.Set, key, Serialize(objects));
}
else
{
SharedCache.Remove(key);
}
}
}
static MemcachedContainerStrategy()
{
// //初始化memcache服务器池
//SockIOPool pool = SockIOPool.GetInstance();
////设置Memcache池连接点服务器端。
//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();
//cache = new MemcachedClient();
//cache.EnableCompression = false;
try
{
//config.Authentication.Type = typeof(PlainTextAuthenticator);
//config.Authentication.Parameters["userName"] = "******";
//config.Authentication.Parameters["password"] = "******";
//config.Authentication.Parameters["zone"] = "zone";//domain? ——Jeffrey 2015.10.20
DateTime dt1 = DateTime.Now;
var config = GetMemcachedClientConfiguration();
var cache = new MemcachedClient(config);
var testKey = Guid.NewGuid().ToString();
var testValue = Guid.NewGuid().ToString();
cache.Store(StoreMode.Set, testKey, testValue);
var storeValue = cache.Get(testKey);
if (storeValue as string != testValue)
{
throw new Exception("MemcachedStrategy失效，没有计入缓存！");
}
cache.Remove(testKey);
DateTime dt2 = DateTime.Now;
WeixinTrace.Log(string.Format("MemcachedStrategy正常启用，启动及测试耗时：{0}ms", (dt2 - dt1).TotalMilliseconds));
}
catch (Exception ex)
{
//TODO:记录是同日志
WeixinTrace.Log(string.Format("MemcachedStrategy静态构造函数异常：{0}", ex.Message));
}
}
public void AddSetReplaceTest()
{
MemcachedClient mc = new MemcachedClient();
mc.Store(StoreMode.Set, "VALUE", "1");
Assert.AreEqual("1", mc.Get("VALUE"), "Store failed");
mc.Store(StoreMode.Add, "VALUE", "2");
Assert.AreEqual("1", mc.Get("VALUE"), "Item should not have been Added");
mc.Store(StoreMode.Replace, "VALUE", "4");
Assert.AreEqual("4", mc.Get("VALUE"), "Replace failed");
mc.Remove("VALUE");
mc.Store(StoreMode.Replace, "VALUE", "8");
Assert.IsNull(mc.Get("VALUE"), "Item should not have been Replaced");
mc.Remove("VALUE");
mc.Store(StoreMode.Add, "VALUE", "16");
Assert.AreEqual("16", mc.Get("VALUE"), "Add failed");
}
public void Delete_Study()
{
using (var client = new MemcachedClient())
{
// 没有键，返回false。
var result1 = client.Remove("userid");
Assert.False(result1);
client.Store(StoreMode.Set, "userid", "123456");
var result2 = client.Remove("userid");
Assert.True(result2);
client.FlushAll();
}
}
static void Main(string[] args)
{
// create a MemcachedClient
// in your application you can cache the client in a static variable or just recreate it every time
MemcachedClient mc = new MemcachedClient();
mc.Get("");
// you can create another client using a different section from your app/web.config
// this client instance can have different pool settings, key transformer, etc.
// MemcachedClient mc2 = new MemcachedClient("memcached");
// or just initialize the client from code
//
// MemcachedClientConfiguration config = new MemcachedClientConfiguration();
// config.Servers.Add(new IPEndPoint(IPAddress.Loopback, 20002));
//
// MemcachedClient mc = new MemcachedClient(config);
// simple multiget; please note that only 1.2.4 supports it (windows version is at 1.2.1)
//List<string> keys = new List<string>();
//for (int i = 1; i < 100; i++)
//{
// string k = "aaaa" + i + "--" + (i * 2);
// keys.Add(k);
// mc.Store(StoreMode.Set, k, i);
//}
//IDictionary<string, ulong> cas;
//IDictionary<string, object> retvals = mc.Get(keys, out cas);
//List<string> keys2 = new List<string>(keys);
//keys2.RemoveRange(0, 50);
//IDictionary<string, object> retvals2 = mc.Get(keys2, out cas);
//retvals2 = mc.Get(keys2, out cas);
//ServerStats ms = mc.Stats();
// store a string in the cache
mc.Store(StoreMode.Set, "MyKey", "Hello World");
// retrieve the item from the cache
Console.WriteLine(mc.Get("MyKey"));
// store some other items
mc.Store(StoreMode.Set, "D1", 1234L);
mc.Store(StoreMode.Set, "D2", DateTime.Now);
mc.Store(StoreMode.Set, "D3", true);
mc.Store(StoreMode.Set, "D4", new Product());
mc.Store(StoreMode.Set, "D5", new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
//mc2.Store(StoreMode.Set, "D1", 1234L);
//mc2.Store(StoreMode.Set, "D2", DateTime.Now);
//mc2.Store(StoreMode.Set, "D3", true);
//mc2.Store(StoreMode.Set, "D4", new Product());
Console.WriteLine("D1: {0}", mc.Get("D1"));
Console.WriteLine("D2: {0}", mc.Get("D2"));
Console.WriteLine("D3: {0}", mc.Get("D3"));
Console.WriteLine("D4: {0}", mc.Get("D4"));
byte[] tmp = mc.Get<byte[]>("D5");
// delete them from the cache
mc.Remove("D1");
mc.Remove("D2");
mc.Remove("D3");
mc.Remove("D4");
ServerStats stats = mc.Stats();
Console.WriteLine(stats.GetValue(ServerStats.All, StatItem.ConnectionCount));
Console.WriteLine(stats.GetValue(ServerStats.All, StatItem.GetCount));
// add an item which is valid for 10 mins
mc.Store(StoreMode.Set, "D4", new Product(), new TimeSpan(0, 10, 0));
Console.ReadLine();
}
public static void test()
{
MemcachedClientConfiguration config = new MemcachedClientConfiguration();
config.Servers.Add(new IPEndPoint(IPAddress.Loopback, 11211));
config.Protocol = MemcachedProtocol.Binary;
//config.Authentication.Type = typeof(PlainTextAuthenticator);
//config.Authentication.Parameters["userName"] = "******";
//config.Authentication.Parameters["password"] = "******";
var mc = new MemcachedClient(config);
for (var i = 0; i < 100; i++)
mc.Store(StoreMode.Set, "Hello", "World");
// simple multiget; please note that only 1.2.4 supports it (windows version is at 1.2.1)
List<string> keys = new List<string>();
for (int i = 1; i < 100; i++)
{
string k = "aaaa" + i + "--" + (i * 2);
keys.Add(k);
mc.Store(StoreMode.Set, k, i);
}
IDictionary<string, ulong> cas;
IDictionary<string, object> retvals = mc.Get(keys);
List<string> keys2 = new List<string>(keys);
keys2.RemoveRange(0, 50);
IDictionary<string, object> retvals2 = mc.Get(keys2);
retvals2 = mc.Get(keys2);
ServerStats ms = mc.Stats();
// store a string in the cache
mc.Store(StoreMode.Set, "MyKey", "Hello World");
// retrieve the item from the cache
Console.WriteLine(mc.Get("MyKey"));
Console.WriteLine(mc.Increment("num1", 1, 10));
Console.WriteLine(mc.Increment("num1", 1, 10));
Console.WriteLine(mc.Decrement("num1", 1, 14));
// store some other items
mc.Store(StoreMode.Set, "D1", 1234L);
mc.Store(StoreMode.Set, "D2", DateTime.Now);
mc.Store(StoreMode.Set, "D3", true);
mc.Store(StoreMode.Set, "D4", new Person());
mc.Store(StoreMode.Set, "D5", new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
//mc2.Store(StoreMode.Set, "D1", 1234L);
//mc2.Store(StoreMode.Set, "D2", DateTime.Now);
//mc2.Store(StoreMode.Set, "D3", true);
//mc2.Store(StoreMode.Set, "D4", new Product());
Console.WriteLine("D1: {0}", mc.Get("D1"));
Console.WriteLine("D2: {0}", mc.Get("D2"));
Console.WriteLine("D3: {0}", mc.Get("D3"));
Console.WriteLine("D4: {0}", mc.Get("D4"));
byte[] tmp = mc.Get<byte[]>("D5");
// delete them from the cache
mc.Remove("D1");
mc.Remove("D2");
mc.Remove("D3");
mc.Remove("D4");
ServerStats stats = mc.Stats();
Console.WriteLine(stats.GetValue(ServerStats.All, StatItem.ConnectionCount));
Console.WriteLine(stats.GetValue(ServerStats.All, StatItem.GetCount));
// add an item which is valid for 10 mins
mc.Store(StoreMode.Set, "D4", new Person(), new TimeSpan(0, 10, 0));
}
static void Main(string[] args)
{
//using (var client = new MemcachedClient())
//{
// client.Store(StoreMode.Set, "currentTime", DateTime.UtcNow.ToString());
// string value = client.Get<string>("currentTime");
// Console.WriteLine(client.Stats());
// Console.WriteLine(value);
// Console.ReadKey();
//}
// create a MemcachedClient
// in your application you can cache the client in a static variable or just recreate it every time
// MemcachedClient mc = new MemcachedClient();
// you can create another client using a different section from your app/web.config
// this client instance can have different pool settings, key transformer, etc.
// MemcachedClient mc2 = new MemcachedClient("memcached");
// or just initialize the client from code
MemcachedClientConfiguration config = new MemcachedClientConfiguration();
config.Servers.Add(new IPEndPoint(IPAddress.Loopback, 11211));
config.Protocol = MemcachedProtocol.Binary;
var mc = new MemcachedClient();
for (var i = 0; i < 100; i++)
mc.Store(StoreMode.Set, "Hello", "World");
var myHello = mc.Get("Hello");
Console.WriteLine(myHello);
// simple multiget; please note that only 1.2.4 supports it (windows version is at 1.2.1)
List<string> keys = new List<string>();
for (int i = 1; i < 100; i++)
{
string k = "aaaa" + i + "--" + (i * 2);
keys.Add(k);
mc.Store(StoreMode.Set, k, i);
}
IDictionary<string, ulong> cas;
IDictionary<string, object> retvals = mc.Get(keys);
List<string> keys2 = new List<string>(keys);
keys2.RemoveRange(0, 50);
IDictionary<string, object> retvals2 = mc.Get(keys2);
retvals2 = mc.Get(keys2);
ServerStats ms = mc.Stats();
// store a string in the cache
mc.Store(StoreMode.Set, "MyKey", "Hello World");
// retrieve the item from the cache
Console.WriteLine("MyKey: {0}", mc.Get("MyKey"));
Console.WriteLine("Increment num1 by 10 {0}", mc.Increment("num1", 1, 10));
Console.WriteLine("Increment num1 by 10 {0}", mc.Increment("num1", 1, 10));
Console.WriteLine("Increment num1 by 14 {0}", mc.Decrement("num1", 1, 14));
//// store some other items
mc.Store(StoreMode.Set, "D1", 1234L);
mc.Store(StoreMode.Set, "D2", DateTime.Now);
mc.Store(StoreMode.Set, "D3", true);
mc.Store(StoreMode.Set, "D4", new Product());
mc.Store(StoreMode.Set, "D5", new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
mc.Store(StoreMode.Set, "D1", 1234L);
mc.Store(StoreMode.Set, "D2", DateTime.Now);
mc.Store(StoreMode.Set, "D3", true);
mc.Store(StoreMode.Set, "D4", new Product());
Console.WriteLine("D1: {0}", mc.Get("D1"));
Console.WriteLine("D2: {0}", mc.Get("D2"));
Console.WriteLine("D3: {0}", mc.Get("D3"));
Console.WriteLine("D4: {0}", mc.Get("D4"));
Console.WriteLine("D5: {0}", System.Text.Encoding.UTF8.GetString(mc.Get<byte[]>("D5")));
Console.WriteLine("Removing D1-D4");
// delete them from the cache
mc.Remove("D1");
mc.Remove("D2");
mc.Remove("D3");
mc.Remove("D4");
//ServerStats stats = mc.Stats();
Console.WriteLine("Active Connections: {0}",ms.GetValue(ServerStats.All, StatItem.ConnectionCount));
Console.WriteLine("GET operations {0}", ms.GetValue(ServerStats.All, StatItem.GetCount));
//// add an item which is valid for 10 mins
mc.Store(StoreMode.Set, "D4", new Product(), new TimeSpan(0, 10, 0));
Console.WriteLine(mc.Stats().GetValue(new IPEndPoint(IPAddress.Loopback, 11211), StatItem.BytesRead));
Console.ReadLine();
}
public void DeleteObjectTest()
{
MemcachedClient mc = new MemcachedClient();
mc.Remove(TestObjectKey);
Assert.IsNull(mc.Get(TestObjectKey), "Remove failed.");
}
private ErrorTypes RemoveFromMC(string sKey)
{
ErrorTypes oError = ErrorTypes.NoError;
try
{
using (MemcachedClient oMc = new MemcachedClient(m_oMcConfig))
{
oMc.Remove(sKey);
}
}
catch
{
oError = ErrorTypes.TaskResult;
}
return oError;
}
/// <summary>
/// 删除缓存(如果键不存在，则返回false)
/// </summary>
/// <param name="key">键</param>
/// <returns>成功:true失败:false</returns>
public static bool DelCache(string key)
{
using (MemcachedClient mc = new MemcachedClient())
{
return mc.Remove(key);
}
}
