public void NullCache() { using (MemcachedClient client = new MemcachedClient("enyim.com/memcached")) { String key = Guid.NewGuid().ToString("n"); Object value = null; client.Store(StoreMode.Set, key, value); var exist = client.TryGet(key, out value); Assert.IsTrue(exist); Assert.IsNull(value); } }
/// <summary> /// 查询用户信息. /// </summary> /// <param name="userName"></param> /// <returns></returns> public TestData GetTestDataByUserName(string userName) { // 尝试从 MemCached 中获取数据. TestData result = client.Get <TestData>(userName); if (result != null) { logger.InfoFormat("从 MemCahced 中,通过关键字 {0}, 查询到数据 {1}", userName, result); } if (result == null) { // MemCached 中没有数据, 尝试 加载. result = realService.GetTestDataByUserName(userName); if (result != null) { // MemCached 中没有,数据库中有, 尝试加入MemCached. // 过期时间. DateTime absoluteExpiration = DateTime.Now.AddMinutes(30); // 指定过期方式。 加入 Memcache. client.Store(StoreMode.Add, userName, result, absoluteExpiration); } } // 返回. return(result); }
public static bool Add(string key, object value, CacheItemPolicy policy) { if (defaultCache != null) { key = key.Replace(' ', '_'); // if (policy.AbsoluteExpiration != null if (policy.SlidingExpiration.Ticks == 0) { if (defaultCache.Store(Enyim.Caching.Memcached.StoreMode.Set, key, value, policy.AbsoluteExpiration.DateTime)) { return(true); } } else { if (defaultCache.Store(Enyim.Caching.Memcached.StoreMode.Set, key, value, policy.SlidingExpiration)) { return(true); } } } return(false); }
public static BlackTable Load() { var version = GetVersion(); var service = ServiceFactory.GetService <ICurrencyService>(); var lst = service.GetBlacklist(); var table = new BlackTable(); table.Version = version; table.CurrenciesNumber = new List <byte[]>(); foreach (var item in lst) { var val = GetCurrencyNumberBytes(item); table.CurrenciesNumber.Add(val); } string key = "BlackTable"; var result = _client.Store(Enyim.Caching.Memcached.StoreMode.Add, key, table); if (!result) { result = _client.Store(Enyim.Caching.Memcached.StoreMode.Replace, key, table); } logger.Info("black table information updated."); return(table); }
public void ExpirationTest() { MemcachedClient mc = new MemcachedClient(); mc.Store(StoreMode.Set, "ExpirationTest:TimeSpan", "ExpirationTest:TimeSpan", new TimeSpan(0, 0, 5)); Assert.AreEqual("ExpirationTest:TimeSpan", mc.Get("ExpirationTest:TimeSpan"), "Expires:Timespan store failed"); Thread.Sleep(8000); Assert.IsNull(mc.Get("ExpirationTest:TimeSpan"), "ExpirationTest:TimeSpan item did not expire"); DateTime expiresAt = DateTime.Now.AddSeconds(5); mc.Store(StoreMode.Set, "Expires:DateTime", "Expires:DateTime", expiresAt); Assert.AreEqual("Expires:DateTime", mc.Get("Expires:DateTime"), "Expires:DateTime store failed"); expiresAt = expiresAt.AddSeconds(4); // wait more than the expiration while (DateTime.Now < expiresAt) { Thread.Sleep(100); } object o = mc.Get("Expires:DateTime"); Assert.IsNull(o, "Expires:DateTime item did not expire"); }
// TODO: !!! routePattern implementation needs to be changed to Cas public void AddOrUpdate(CacheKey key, TimedEntityTagHeaderValue eTag) { // add item _memcachedClient.Store(StoreMode.Set, key.HashBase64, eTag.ToString()); // add route pattern if not there string keyForRoutePattern = GetKeyForRoutePattern(key.RoutePattern); string keyForResourceUri = GetKeyForResourceUri(key.ResourceUri); var routePatternEntries = GetRoutePatternEntries(key.RoutePattern); var resourceUriEntries = GetResourceUriEntries(key.ResourceUri); if (!routePatternEntries.Contains(key.HashBase64)) { var bytes = new List <byte>(); foreach (var routePatternEntry in routePatternEntries) { bytes.AddRange(new LengthedPrefixedString(routePatternEntry).ToByteArray()); } bytes.AddRange(new LengthedPrefixedString(key.HashBase64).ToByteArray()); _memcachedClient.Store(StoreMode.Set, keyForRoutePattern, bytes.ToArray()); } if (!resourceUriEntries.Contains(key.HashBase64)) { var bytes = new List <byte>(); foreach (var entry in resourceUriEntries) { bytes.AddRange(new LengthedPrefixedString(entry).ToByteArray()); } bytes.AddRange(new LengthedPrefixedString(key.HashBase64).ToByteArray()); _memcachedClient.Store(StoreMode.Set, keyForResourceUri, bytes.ToArray()); } }
public void StoreWithProtoTranscoder() { var config = GetConfig(); var transcoder = new ProtoBuf.Caching.Enyim.NetTranscoder(); config.Transcoder = transcoder; SomeType obj = new SomeType { Id = 1, Name = "abc" }, clone; string cloneString; Assert.AreEqual(0, transcoder.Deserialized); Assert.AreEqual(0, transcoder.Serialized); using (var client = new MemcachedClient(config)) { client.Store(StoreMode.Set, "raw1", obj); client.Store(StoreMode.Set, "raw2", "def"); } Assert.AreEqual(0, transcoder.Deserialized); Assert.AreEqual(1, transcoder.Serialized); using (var client = new MemcachedClient(config)) { clone = (SomeType)client.Get("raw1"); cloneString = (string)client.Get("raw2"); } Assert.AreEqual(1, transcoder.Deserialized); Assert.AreEqual(1, transcoder.Serialized); Assert.AreEqual(1, clone.Id); Assert.AreEqual("abc", clone.Name); Assert.AreEqual("def", cloneString); }
public void StoreWithProtoTranscoder() { var config = GetConfig(); var transcoder = new AqlaSerializer.Caching.Enyim.NetTranscoder(); config.Transcoder = transcoder; SomeType obj = new SomeType { Id = 1, Name = "abc" }, clone; string cloneString; Assert.AreEqual(0, transcoder.Deserialized); Assert.AreEqual(0, transcoder.Serialized); using (var client = new MemcachedClient(config)) { client.Store(StoreMode.Set, "raw1", obj); client.Store(StoreMode.Set, "raw2", "def"); } Assert.AreEqual(0, transcoder.Deserialized); Assert.AreEqual(1, transcoder.Serialized); using (var client = new MemcachedClient(config)) { clone = (SomeType)client.Get("raw1"); cloneString = (string)client.Get("raw2"); } Assert.AreEqual(1, transcoder.Deserialized); Assert.AreEqual(1, transcoder.Serialized); Assert.AreEqual(1, clone.Id); Assert.AreEqual("abc", clone.Name); Assert.AreEqual("def", cloneString); }
public void Set(string key, object value, CacheSetting itemInfo) { lock (thisLock) { DateTime expiredtime = DateTime.Now; switch (itemInfo.ExpirationMode) { case CacheExpirationMode.Absolute: expiredtime = itemInfo.AbsoluteExpiration; break; case CacheExpirationMode.Sliding: expiredtime = expiredtime.Add(itemInfo.SlidingExpiration); break; case CacheExpirationMode.Never: client.Store(StoreMode.Set, key, value); return; default: break; } client.Store(StoreMode.Set, key, value, expiredtime); } }
/// <summary> /// Inserts an item into the cache with a cache key to reference its location. /// </summary> /// <typeparam name="T">Dependency object to be find child from.</typeparam> /// <param name="key">The key used to reference the item.</param> /// <param name="value">The object to be inserted into the cache.</param> /// <param name="expiration">The expiration time of the cached object</param> /// public void Put <T>(string key, T value, TimeSpan expiration) where T : class { this.CheckParamKey(key); this.CheckParamValue(value); _mc.Store(StoreMode.Set, key, value, expiration); }
public IHttpActionResult Init() { memcache.Store(StoreMode.Set, "matrix_multiplication", benchmarkingService.GetMatrixMultiplicationData()); memcache.Store(StoreMode.Set, "sieve_of_atkin", benchmarkingService.GetSieveOfAtkinData()); memcache.Store(StoreMode.Set, "quicksort", benchmarkingService.GetQuicksortData()); return(Ok()); }
public virtual void Init() { var state = _client.Get <int>(Prefix + "g"); if (state > 0) { return; } var items = LoadItems(); foreach (var item in items) { var key = Prefix + GetItemKey(item); var result = _client.Store(Enyim.Caching.Memcached.StoreMode.Add, key, item); if (!result) { result = _client.Store(Enyim.Caching.Memcached.StoreMode.Replace, key, item); if (!result) { throw new InvalidOperationException("memecached store failed"); } } } _client.Store(Enyim.Caching.Memcached.StoreMode.Add, Prefix + "g", 1); }
public static bool Set(string key, object value, StoreMode mode = StoreMode.Set) { if (string.IsNullOrEmpty(key)) { key = GetUniqueKey(); } return(client.Store(mode, key, value)); }
public void add(String player) { if (memcachedClient.Get <string>(player) == null) { memcachedClient.Store(StoreMode.Add, player, 0); } memcachedClient.Store(StoreMode.Replace, player, (int.Parse(memcachedClient.Get <string>(player)) + 1)); }
public static void Store(this MemcachedClient client, string key, object item) { var result = client.Store(Enyim.Caching.Memcached.StoreMode.Add, key, item); if (!result) { client.Store(Enyim.Caching.Memcached.StoreMode.Replace, key, item); } }
private static void Set(Guid eTag, string key) { //wrap the guid in double-quotes so the ETag is stored in client header format: var value = Wrap(eTag); _Cache.Store(StoreMode.Set, key, value); //store the URL against the ETag so we can do a reverse-lookup for updates: _Cache.Store(StoreMode.Set, value, key); }
public bool Set(string key, object value, double minute = 10d, string regionName = null) { if (minute <= 0) { throw new ArgumentException("缓存过期时间必须大于0"); } return(value != null && memClient.Store(StoreMode.Set, GetCacheKey(key, regionName), value, TimeSpan.FromMinutes(minute))); }
public Stream CreateRequestStream(string requestId) { _logger?.Verbose("Creating stream for storing request body. request-id={RequestId}", requestId); var ms = new NotifyingMemoryStream(); ms.Disposing += (s, e) => _memcachedClient.Store(StoreMode.Set, requestId, (s as NotifyingMemoryStream)?.ToArray(), _storagePeriod); return(ms); }
/// <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); } }
public static bool AddOrReplace(this MemcachedClient client, string key, object item) { var result = client.Store(StoreMode.Add, key, item); if (!result) { result = client.Store(StoreMode.Replace, key, item); } return(result); }
public void Set(string key, object data, int cacheTime) { try { MemClient.Store(StoreMode.Set, key, data, DateTime.Now.AddSeconds(cacheTime)); } catch (Exception) { //igore } }
public bool AddItem(System.Runtime.Caching.CacheItem item, int seconds = -1) { if (seconds > 0) { TimeSpan ts = new TimeSpan(seconds * 1000); return(client.Store(StoreMode.Add, item.Key, item.Value, ts)); } else { return(client.Store(StoreMode.Add, item.Key, item.Value)); } }
public void InsertToCache(string key, object value)//TODO:添加Timeout参数 { if (string.IsNullOrEmpty(key) || value == null) { return; } var cacheKey = GetFinalKey(key); //TODO:加了绝对过期时间就会立即失效(再次获取后为null),memcache低版本的bug _cache.Store(StoreMode.Set, cacheKey, value, DateTime.Now.AddDays(1)); }
/// <summary> /// 使用Add模式添加缓存,如果同名Key已存在返回false /// </summary> public static bool AddCacheExplicit(string key, object value, int minutes = 10) { if (!IsUsedCache) { return(false); } if (minutes <= 0) { return(Mc.Store(StoreMode.Add, key, value)); } return(Mc.Store(StoreMode.Add, key, value, TimeSpan.FromMinutes(minutes))); }
public void RunProgram() { const string key = "testkey"; var cacheClient = new MemcachedClient(ConfigurationManager.GetSection("enyim.com/memcached") as IMemcachedClientConfiguration); cacheClient.Store(StoreMode.Add, key, "testvalue"); var item = cacheClient.Get(key); Console.WriteLine(item); cacheClient.Store(StoreMode.Set, key, "something else"); item = cacheClient.Get(key); Console.WriteLine(item); }
public override void Save(string key, object value, int seconds) { if (seconds > 0) { var date = DateTime.Now; date.AddSeconds(seconds); Instance.Store(StoreMode.Set, key, value, date); } else { Instance.Store(Enyim.Caching.Memcached.StoreMode.Set, key, value); } }
public int Create(string name) { var keys = GetProductKeys(); var newKey = keys.GetNextKey(); client.Store(StoreMode.Add, newKey.ToString(), new Product { Id = newKey, Name = name }); UpdateProductKeys(keys); return(newKey); }
public void SetDemo() { Person person = new Person { UserId = 1, UserName = "******" }; //不带过期时间的存储,Memcached将根据LRU来决定过期策略 bool success = client.Store(StoreMode.Add, person.UserName, person); Console.WriteLine("存储[{0}]的结果:{1}", person.UserName, success); //带过期时间的缓存 success = client.Store(StoreMode.Add, person.UserName, person, DateTime.Now.AddMinutes(10)); Console.WriteLine("存储[{0}]的结果:{1}", person.UserName, success); }
/// <summary> /// 插入指定值 /// </summary> /// <param name="key">缓存名称 </param> /// <param name="value">缓存值</param> /// <returns>返回是否成功</returns> public bool Insert(string key, string value) { MemcachedClient mc = getInstance(); var data = mc.Get(key); if (data == null) { return(mc.Store(StoreMode.Add, MemPrefix + key, value)); } else { return(mc.Store(StoreMode.Replace, MemPrefix + key, value)); } }
public void RunProgram() { const string key = "testkey"; var cacheClient = new MemcachedClient(ConfigurationManager.GetSection("enyim.com/memcached") as IMemcachedClientConfiguration); cacheClient.Store(StoreMode.Add, key, "testvalue"); var item = cacheClient.Get(key); Console.WriteLine(item); cacheClient.Store(StoreMode.Set, key, "something else"); item = cacheClient.Get(key); Console.WriteLine(item); }
public void Add_Study() { using (var client = new MemcachedClient()) { var result1 = client.Store(StoreMode.Add, "userid", "123456"); Assert.True(result1); // 不可以多次调用 var result2 = client.Store(StoreMode.Add, "userid", "123456"); Assert.False(result2); client.FlushAll(); } }
/// <summary> /// 插入指定值 /// </summary> /// <param name="key">缓存名称 </param> /// <param name="value">缓存值</param> /// <param name="dateTime">过期时间</param> /// <returns>返回是否成功</returns> // public static bool Set(string key, string value, int minutes = 10080) public static bool Set(string key, string value, DateTime dateTime) { MemcachedClient mc = getInstance(); var data = mc.Get(key); if (data == null) { return(mc.Store(StoreMode.Add, key, value, dateTime)); } else { return(mc.Store(StoreMode.Replace, key, value, dateTime)); } }
//配置&存入&读取&删除 public static void Test1() { #region 说明 //NuGet:PM> Install-Package EnyimMemcached //关于MemCached的程序包有很多,EnyimMemcached只是其一 //Memcache 存入数据的 3 中模式 Set、Replace、Add,根据名字就能猜出来: //Set:存在则覆盖,不存在则新增 //Replace:如果存在则覆盖,并且返回 true;如果不存在则不处理,并且返回 false;(Replace,为替换,能替换的意义就是先存在) //Add:如果不存在则新增,并且返回 true;如果存在则不处理,并且返回 false(Add,为新增,能新增的前提是之前不存在) //常用的就是Set方式 //注意数据是存放在MemCached服务器中的,你重启程序依旧在服务器中存在你存入的数据 //但是你一旦重启memcached服务器,则数据就消失了 #endregion //创建配置对象 MemcachedClientConfiguration memConfig = new MemcachedClientConfiguration(); memConfig.AddServer("127.0.0.1:11211"); //若是Memcached集群,此处可以同时添加多个服务器ip地址,然后客户端根据自己的算法决定把数据写入哪个 Memcached 实例 //创建MemcachedClient对象 using (MemcachedClient memClient = new MemcachedClient(memConfig)) { //写入MemCached中 memClient.Store(Enyim.Caching.Memcached.StoreMode.Set, "Name", "shanzm"); memClient.Store(Enyim.Caching.Memcached.StoreMode.Set, "Age", "100"); //读取数据 // string name = (string)memClient.Get("Name");//Get<T>()是一个泛型方法,你可直接使用Get()函数得到一个Object类型的对象,或提供泛型类型 string name = memClient.Get <string>("Name"); if (name == null) { Console.WriteLine("无缓存"); } else { Console.WriteLine(name); } //删除数据 Console.WriteLine(memClient.Get <string>("Age")); memClient.Remove("Age"); if (null == memClient.Get <string>("Age")) { Console.WriteLine("已经将Key为Age的数据从MemCached服务器中清除"); } Console.ReadKey(); } }
public bool Set <T>(string key, T value) { try { if (mc == null) { return(false); } return(mc.Store(StoreMode.Set, key, value)); } catch (Exception ex) { throw ex; } }
public void Replace_Study() { using (var client = new MemcachedClient()) { // 没有键,不能替换。 var result1 = client.Store(StoreMode.Replace, "userid", "123456"); Assert.False(result1); // 有的话,就可以。 client.Store(StoreMode.Add, "userid", "123456"); var result2 = client.Store(StoreMode.Replace, "userid", "123456"); Assert.True(result2); client.FlushAll(); } }
/// <summary> /// 添加缓存(键不存在则添加,存在则替换) /// </summary> /// <param name="key">键</param> /// <param name="value">值</param> /// <param name="minutes">缓存时间(分钟)</param> /// <returns></returns> public static bool AddCache(string key, object value, int minutes) { using (MemcachedClient mc = new MemcachedClient()) { return mc.Store(StoreMode.Set, key, value, DateTime.Now.AddMinutes(minutes)); } }
public void TestThem(List<string> servers) { var mbc = new MemcachedClientConfiguration(); foreach (var server in servers) { IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(server), 11211); mbc.Servers.Add(endPoint); } _couchbaseClient = new MemcachedClient(mbc); _couchbaseClient.Store(StoreMode.Set, Key, Value); Debug.Assert((string)_couchbaseClient.Get(Key) == Value); List<Thread> workers = new List<Thread>(); for (int s = 0; s < NumThreads; s++) { Thread workerThread = new Thread(Run); workerThread.Start(); workers.Add(workerThread); } foreach (var thread in workers) { while (thread.IsAlive) { Thread.Sleep(1); } thread.Join(); } }
static void testMemcachedProviders() { MemcachedClient client = new MemcachedClient("enyim.com/memcached"); //存值 --不带过期时间的存储,Memcached将根据LRU来决定过期策略 bool result = client.Store(Enyim.Caching.Memcached.StoreMode.Add, "name", "dinglang"); //带过期时间的缓存 //bool success = client.Store(StoreMode.Add, person.UserName, person, DateTime.Now.AddMinutes(10)); if (result) { Console.Write("成功存入缓存"); //取值 object name = client.Get("name"); if (name != null) { Console.Write("取出的值为:" + name); } else { Console.Write("取值失败"); } } else { Console.Write("存入缓存失败"); } }
/// <summary> /// 添加缓存(键不存在则添加,存在则替换) /// </summary> /// <param name="key">键</param> /// <param name="value">值</param> /// <returns></returns> public static bool AddCache(string key, object value) { using (MemcachedClient mc = new MemcachedClient()) { return mc.Store(StoreMode.Set, key, value); } }
public void DecrementTest() { MemcachedClient mc = new MemcachedClient(); mc.Store(StoreMode.Set, "VALUE", "100"); Assert.AreEqual(98L, mc.Decrement("VALUE", 2)); Assert.AreEqual(88L, mc.Decrement("VALUE", 10)); }
public void CanCacheString() { var client = new MemcachedClient(); client.Store(StoreMode.Add, "a", "b"); var result = client.Get<string>("a"); Assert.AreEqual("b", result); }
public void CanCacheList() { var client = new MemcachedClient(); var list = new List<string> { "a", "b" }; client.Store(StoreMode.Set, "d", list); var result = client.Get<List<string>>("d"); Assert.AreEqual(2, result.Count); Assert.AreEqual("a", result[0]); Assert.AreEqual("b", result[1]); }
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 CanCacheDTO() { var client = new MemcachedClient(); var obj = new Dto { Name = "b", Title = "c" }; client.Store(StoreMode.Set, "c", obj); var result = client.Get<Dto>("c"); Assert.AreEqual("b", result.Name); Assert.AreEqual("c", result.Title); }
public void Get_Study() { using (var client = new MemcachedClient()) { // 没有键,返回null。 var result1 = client.Get("userid"); Assert.Null(result1); client.Store(StoreMode.Set, "userid", "123456"); var result2 = client.Get("userid"); Assert.AreEqual("123456", result2); client.FlushAll(); } }
public void StoreWithDefaultTranscoder() { var config = GetConfig(); SomeType obj = new SomeType { Id = 1, Name = "abc" }, clone; using (var client = new MemcachedClient(config)) { client.Store(StoreMode.Set, "raw1", obj); } using (var client = new MemcachedClient(config)) { clone = (SomeType) client.Get("raw1"); } Assert.AreEqual(1, clone.Id); Assert.AreEqual("abc", clone.Name); }
private static void StressTest(MemcachedClient client, string keyPrefix) { var i = 0; var last = true; var progress = @"-\|/".ToCharArray(); Console.CursorVisible = false; Dictionary<bool, int> counters = new Dictionary<bool, int>() { { true, 0 }, { false, 0 } }; while (true) { var key = keyPrefix + i; var state = client.Store(StoreMode.Set, key, i) & client.Get<int>(key) == i; Action updateTitle = () => Console.Title = "Success: " + counters[true] + " Fail: " + counters[false]; if (state != last) { Console.ForegroundColor = state ? ConsoleColor.White : ConsoleColor.Red; Console.Write("."); counters[state] = 0; last = state; updateTitle(); } else if (i % 200 == 0) { //Console.ForegroundColor = state ? ConsoleColor.White : ConsoleColor.Red; //Console.Write(progress[(i / 200) % 4]); //if (Console.CursorLeft == 0) //{ // Console.CursorLeft = Console.WindowWidth - 1; // Console.CursorTop -= 1; //} //else //{ // Console.CursorLeft -= 1; //} updateTitle(); } i++; counters[state] = counters[state] + 1; } }
public void CanConnectToMemcached() { var config = GetConfig(); string s1 = Guid.NewGuid().ToString(); string s2 = Guid.NewGuid().ToString(); Assert.AreNotEqual(s1, s2); using (var client1 = new MemcachedClient(config)) using (var client2 = new MemcachedClient(config)) { client1.Store(StoreMode.Set, "key1", s1); client2.Store(StoreMode.Set, "key2", s2); Assert.AreEqual(s2, client1.Get("key2"), "client1.key2"); Assert.AreEqual(s1, client2.Get("key1"), "client2.key1"); } }
public void ShouldBeAbleToCacheContractTypes() { ContractType original = new ContractType { Id = 123, Name = "abc" }, clone; using (var client = new MemcachedClient()) { client.Store(StoreMode.Set, "ShouldBeAbleToCacheBasicTypes", original); } using (var client = new MemcachedClient()) { clone = client.Get<ContractType>("ShouldBeAbleToCacheBasicTypes"); } Assert.IsNotNull(clone); Assert.AreNotSame(original, clone); Assert.AreEqual(original.Id, clone.Id); Assert.AreEqual(original.Name, clone.Name); }
public void Compatibility() { using (MemcachedClient client = new MemcachedClient("enyim.com/memcached")) { var array = new List<Object>(); array.Add(new Object()); array.Add(Guid.NewGuid().GetHashCode()); array.Add(1.1m); array.Add(Guid.NewGuid()); array.Add(Guid.NewGuid().GetHashCode().ToString()); array.Add(new[] { 1, 2 }); array.Add(new[] { Guid.NewGuid().ToString() }); array.Add(new Person { Id = 2, Name = "Rattz", Address = new Address { Line1 = "Haidin Shuzhoujie", Line2 = "Beijing China" } }); var transcoderProp = typeof(MemcachedClient).GetField("transcoder", BindingFlags.Instance | BindingFlags.NonPublic); var region = Guid.NewGuid().ToString("n"); region = "Compatibility"; for (var i = 0; i < array.Count; i++) { if ((Guid.NewGuid().GetHashCode() % 2) == 1) { transcoderProp.SetValue(client, new NewtonsoftJsonTranscoder()); } else { transcoderProp.SetValue(client, new DefaultTranscoder()); } var key = region + "_" + i; client.Store(StoreMode.Set, key, array[i]); transcoderProp.SetValue(client, new NewtonsoftJsonTranscoder()); Object cache; Assert.IsTrue(client.TryGet(key, out cache)); //Assert.AreEqual(array[i].GetType(), cache.GetType()); Assert.AreEqual(JsonConvert.SerializeObject(array[i]), JsonConvert.SerializeObject(cache)); } } }
public void Online() { using (MemcachedClient client = new MemcachedClient("enyim.com/memcached")) { String key = Guid.NewGuid().ToString("n"); Object value = client.Get(key); Assert.IsNull(value); var exist = client.TryGet(key, out value); Assert.IsFalse(exist); Assert.IsNull(value); value = new Person { Id = 2, Name = "Rattz", Address = new Address { Line1 = "Haidin Shuzhoujie", Line2 = "Beijing China" } }; client.Store(StoreMode.Set, key, value); exist = client.TryGet(key, out value); Assert.IsTrue(exist); Assert.IsNotNull(value); } }
public MemcachedCache() { Cache = new MemcachedClient(); List<string> keys = new List<string>(); Cache.Store(StoreMode.Add, "keys", keys); }
public void StoreArrayTest() { byte[] bigBuffer = new byte[200 * 1024]; for (int i = 0; i < bigBuffer.Length / 256; i++) { for (int j = 0; j < 256; j++) { bigBuffer[i * 256 + j] = (byte)j; } } MemcachedClient mc = new MemcachedClient(); mc.Store(StoreMode.Set, "BigBuffer", bigBuffer); byte[] bigBuffer2 = mc.Get<byte[]>("BigBuffer"); for (int i = 0; i < bigBuffer.Length / 256; i++) { for (int j = 0; j < 256; j++) { if (bigBuffer2[i * 256 + j] != (byte)j) { Assert.AreEqual(j, bigBuffer[i * 256 + j], "Data should be {0} but its {1}"); break; } } } }
public void ExpirationTest() { MemcachedClient mc = new MemcachedClient(); mc.Store(StoreMode.Set, "ExpirationTest:TimeSpan", "ExpirationTest:TimeSpan", new TimeSpan(0, 0, 5)); Assert.AreEqual("ExpirationTest:TimeSpan", mc.Get("ExpirationTest:TimeSpan"), "Expires:Timespan store failed"); Thread.Sleep(8000); Assert.IsNull(mc.Get("ExpirationTest:TimeSpan"), "ExpirationTest:TimeSpan item did not expire"); DateTime expiresAt = DateTime.Now.AddSeconds(5); mc.Store(StoreMode.Set, "Expires:DateTime", "Expires:DateTime", expiresAt); Assert.AreEqual("Expires:DateTime", mc.Get("Expires:DateTime"), "Expires:DateTime store failed"); expiresAt = expiresAt.AddSeconds(4); // wait more than the expiration while (DateTime.Now < expiresAt) { Thread.Sleep(100); } object o = mc.Get("Expires:DateTime"); Assert.IsNull(o, "Expires:DateTime item did not expire"); }
public void MultiGetTest() { // note, this test will fail, if memcached version is < 1.2.4 MemcachedClient mc = new MemcachedClient(); List<string> keys = new List<string>(); for (int i = 0; i < 100; i++) { string k = "multi_get_test_" + i; keys.Add(k); mc.Store(StoreMode.Set, k, i); } IDictionary<string, ulong> cas; IDictionary<string, object> retvals = mc.Get(keys, out cas); Assert.AreEqual<int>(100, retvals.Count, "MultiGet should have returned 100 items."); object value; for (int i = 0; i < retvals.Count; i++) { string key = "multi_get_test_" + i; Assert.IsTrue(retvals.TryGetValue(key, out value), "missing key: " + key); Assert.AreEqual(value, i, "Invalid value returned: " + value); } }
public void FlushTest() { MemcachedClient mc = new MemcachedClient(); mc.Store(StoreMode.Set, "qwer", "1"); mc.Store(StoreMode.Set, "tyui", "1"); mc.Store(StoreMode.Set, "polk", "1"); mc.Store(StoreMode.Set, "mnbv", "1"); mc.Store(StoreMode.Set, "zxcv", "1"); mc.Store(StoreMode.Set, "gfsd", "1"); Assert.AreEqual("1", mc.Get("mnbv"), "Setup for FlushAll() failed"); mc.FlushAll(); Assert.IsNull(mc.Get("qwer"), "FlushAll() failed."); Assert.IsNull(mc.Get("tyui"), "FlushAll() failed."); Assert.IsNull(mc.Get("polk"), "FlushAll() failed."); Assert.IsNull(mc.Get("mnbv"), "FlushAll() failed."); Assert.IsNull(mc.Get("zxcv"), "FlushAll() failed."); Assert.IsNull(mc.Get("gfsd"), "FlushAll() failed."); }
private ErrorTypes AddToMCWithCas(string sKey, TaskResultData oTast, ulong cas) { ErrorTypes oError = ErrorTypes.NoError; try { using (MemcachedClient oMc = new MemcachedClient(m_oMcConfig)) { string sDataToStore = null; XmlSerializer oXmlSerializer = new XmlSerializer(typeof(TaskResultData)); using (StringWriter oStringWriter = new StringWriter()) { oXmlSerializer.Serialize(oStringWriter, oTast); sDataToStore = oStringWriter.ToString(); } if (cas != 0) oMc.Cas(StoreMode.Set, sKey, sDataToStore, m_oTtl, cas); else oMc.Store(StoreMode.Set, sKey, sDataToStore, m_oTtl); } } catch { oError = ErrorTypes.TaskResult; } return oError; }
private static long TestMemcachedWrite(int length) { var client = new MemcachedClient(); var sw = Stopwatch.StartNew(); for (int i = 0; i < length; i++) { client.Store(StoreMode.Set, "asdfasdf" + i.ToString(), stringToTest); } sw.Stop(); client.Dispose(); return sw.ElapsedMilliseconds; }
public void StoreLongTest() { MemcachedClient mc = new MemcachedClient(); mc.Store(StoreMode.Set, "TestLong", 65432123456L); Assert.AreEqual(65432123456L, mc.Get<long>("TestLong")); }