Beispiel #1
0
 public void AddCache(string cacheKey, ISQLCacheItem cacheItem, int cacheTime, int duringTime)
 {
     if (cacheTime == -1)
     {
         m_cache.TryAdd(cacheKey, cacheItem);
     }
     else
     {
         if (cacheTime > 0)
         {
             _memoryCache.Add(new CacheItem(cacheKey)
             {
                 Key = cacheKey, Value = cacheItem
             }, new CacheItemPolicy {
                 AbsoluteExpiration = new DateTimeOffset(DateTime.Now, new TimeSpan(0, 0, cacheTime))
             });
         }
         else if (duringTime > 0)
         {
             _memoryCache.Add(new CacheItem(cacheKey)
             {
                 Key = cacheKey, Value = cacheItem
             }, new CacheItemPolicy {
                 SlidingExpiration = new TimeSpan(0, 0, duringTime)
             });
         }
     }
 }
        public void CrearCacheHorasTotales()
        {
            var cacheItemPolicy = new CacheItemPolicy
            {
                AbsoluteExpiration = DateTimeOffset.Now.AddDays(1)
            };
            OdbcConnection con         = new OdbcConnection(connectionString);
            string         queryString = "SELECT No_Cuenta, sum(Horas_Acum) FROM [Tabla General] Group By No_Cuenta;";
            OdbcCommand    command     = new OdbcCommand(queryString, con);

            con.Open();
            OdbcDataReader reader = command.ExecuteReader();

            //Console.WriteLine(reader.FieldCount);
            while (reader.Read())
            {
                var cacheIt = new CacheItem(reader.GetString(0), reader.GetString(1));
                cache.Add(cacheIt, cacheItemPolicy);
            }
            reader.Close();
            var chek = cache.Get("21841180");

            //Console.WriteLine(chek);

            /*foreach (var item in cache)
             * {
             *  Console.WriteLine($"{item.Key} : {item.Value}");
             * }*/
            Console.WriteLine("Caché creado con éxito!");
        }
Beispiel #3
0
 public void ClearAllCachesTest()
 {
     const string prefix = "123123af";
     var fk1 = FullKey(prefix, "111");
     var fk2 = FullKey(prefix, "222");
     var memoryCache = new MemoryCache("sdgkmnsdlkghn");
     _objectCacheFactory.Setup(x => x.Create()).Returns(memoryCache).Verifiable();
     Assert.AreEqual(0, memoryCache.GetCount());
     memoryCache.Add(fk1, new MemoryCacherTests.One(), new CacheItemPolicy());
     memoryCache.Add(fk2, new MemoryCacherTests.One(), new CacheItemPolicy());
     Assert.AreEqual(2, memoryCache.Count());
     new CacheCleaner(_objectCacheFactory.Object).Clean();
     Assert.AreEqual(0, memoryCache.GetCount());
 }
            private void StoreRootCacheKey()
            {
                rootCacheKeyStored = true;

                cache.Add(
                    rootCacheKey,
                    rootCacheKey,
                    new CacheItemPolicy {
                    Priority        = CacheItemPriority.NotRemovable,
                    RemovedCallback = new CacheEntryRemovedCallback(args => {
                        rootCacheKeyStored = false;
                    })
                });
            }
Beispiel #5
0
        /// <summary>
        /// Get cached item.
        /// </summary>
        /// <typeparam name="T">item type</typeparam>
        /// <param name="key">item key</param>
        /// <param name="getItem">get item function</param>
        /// <param name="update">if true force item update via getItem, otherwise default behavior</param>
        /// <returns>item</returns>
        public T Get <T>(NonNullable <string> key, Func <T> getItem, bool update) where T : class
        {
            if (!update && _cache.Get(CacheKey <T>(key)) is T item)
            {
                return(item);
            }

            item = getItem();
            var cacheItemPolicy = new CacheItemPolicy {
                AbsoluteExpiration = DateTime.Now.AddMilliseconds(_lifetimeMilliseconds)
            };

            _cache.Add(CacheItem(key, item), cacheItemPolicy);
            return(item);
        }
        public void ShouldExpireCacheAfterConfigurableTime()
        {
            const string PolicyKey = "MDM.Market";

            var appSettings = new NameValueCollection();
            appSettings["CacheItemPolicy.Expiration." + PolicyKey] = "8";

            var configManager = new Mock<IConfigurationManager>();
            configManager.Setup(x => x.AppSettings).Returns(appSettings);

            ICacheItemPolicyFactory policyFactory = new AbsoluteCacheItemPolicyFactory(PolicyKey, configManager.Object);
            var policyItem = policyFactory.CreatePolicy();

            var marketName = "ABC market";
            var marketKey = "Market-1";
            var cache = new MemoryCache("MDM.Market");
            cache.Add(marketKey, marketName, policyItem);

            // Should get cache item
            Assert.AreEqual(marketName, cache[marketKey]);

            // Keep on accessing cache, it should expire approximately with in 10 iterations
            int count = 0;
            while (cache[marketKey] != null && count < 10)
            {
                count++;
                Thread.Sleep(TimeSpan.FromSeconds(1));
            }

            Console.WriteLine("Cache has expired in {0} seconds:", count);
            // should not be in the cache after configuratble time
            Assert.IsNull(cache[marketKey]);
        }
        public void ShouldCreateAbsoluteCacheItemPolicyBasedOnTheConfiguration()
        {
            const string PolicyKey = "MDM.Market";

            var appSettings = new NameValueCollection();
            appSettings["CacheItemPolicy.Expiration." + PolicyKey] = "8";

            var configManager = new Mock<IConfigurationManager>();
            configManager.Setup(x => x.AppSettings).Returns(appSettings);

            ICacheItemPolicyFactory policyFactory = new AbsoluteCacheItemPolicyFactory(PolicyKey, configManager.Object);
            var policyItem = policyFactory.CreatePolicy();

            var marketName = "ABC market";
            var marketKey = "Market-1";
            var cache = new MemoryCache("MDM.Market");
            cache.Add(marketKey, marketName, policyItem);

            // Should get cache item
            Assert.AreEqual(marketName, cache[marketKey]);

            // wait until the expiry time
            Thread.Sleep(TimeSpan.FromSeconds(10));

            // should not be in the cache
            Assert.IsNull(cache[marketKey]);
        }
Beispiel #8
0
        public void Add(string key, object o, TimeSpan?expiry, When when)
        {
            lock (_lockObj)
            {
                if (when == When.Exists && !_cache.Contains(key))
                {
                    return;
                }

                if (when == When.NotExists && _cache.Contains(key))
                {
                    return;
                }

                _cache.Remove(key);

                CacheItemPolicy policy = new CacheItemPolicy();

                if (expiry.HasValue && expiry.Value != default(TimeSpan))
                {
                    //Store the ttl separately
                    _ttls[key] = policy.AbsoluteExpiration = DateTime.UtcNow.Add(expiry.Value);
                }
                else
                {
                    _ttls[key] = null;
                }

                System.Diagnostics.Debug.WriteLine("Adding key to mem cache: " + key);
                _cache.Add(key, o, policy);
            }
        }
Beispiel #9
0
        /// <summary>
        /// 新增缓存项
        /// </summary>
        /// <param name="key">Key</param>
        /// <param name="value">Value</param>
        /// <param name="expireTime">过期时间</param>
        public void SetCache <T>(string key, T value, DateTime expireTime)
        {
            var policy = new CacheItemPolicy();

            policy.AbsoluteExpiration = expireTime;
            mc.Add(new CacheItem(key, value), policy);
        }
        /// <summary>
        /// Sets the specified identifier.
        /// </summary>
        /// <param name="id">The identifier.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <param name="value">The value.</param>
        /// <param name="ttl">The TTL.</param>
        /// <param name="overwrite">if set to <c>true</c> [overwrite].</param>
        public void Set(string id, string propertyName, object value, TimeSpan?ttl = null, bool overwrite = true)
        {
            if (!ttl.HasValue)
            {
                ttl = _defaultTtl;
            }

            if (overwrite)
            {
                _cache.Set(getPropertyId(id, propertyName), value, getCacheItemPolicy(ttl.Value));
            }
            else
            {
                _cache.Add(getPropertyId(id, propertyName), value, getCacheItemPolicy(ttl.Value));
            }
        }
Beispiel #11
0
        public void Set(Guid id, AggregateRoot aggregate)
        {
#if NET461
            _cache.Add(id.ToString(), aggregate, _policyFactory.Invoke());
#else
            _cache.Set(id, aggregate, _cacheOptions);
#endif
        }
        public void Set(string id, AggregateRoot aggregate)
        {
#if NET451
            _cache.Add(id, aggregate, _policyFactory.Invoke());
#else
            _cache.Set(id, aggregate, _cacheOptions);
#endif
        }
Beispiel #13
0
        public void Put(object key, object value)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key", "null key not allowed");
            }

            if (value == null)
            {
                throw new ArgumentNullException("value", "null value not allowed");
            }

            var cacheKey = GetCacheKey(key);

            if (cache[cacheKey] != null)
            {
                if (log.IsDebugEnabled)
                {
                    log.Debug(string.Format("updating value of key '{0}' to '{1}'.", cacheKey, value));
                }

                // Remove the key to re-add it again below
                cache.Remove(cacheKey);
            }
            else
            {
                if (log.IsDebugEnabled)
                {
                    log.Debug(string.Format("adding new data: key={0}&value={1}", cacheKey, value));
                }
            }

            if (!rootCacheKeyStored)
            {
                StoreRootCacheKey();
            }

            var entry           = new DictionaryEntry(key, value);
            var cacheItemPolicy = new CacheItemPolicy
            {
                AbsoluteExpiration = DateTime.Now.Add(expiration),
                SlidingExpiration  = ObjectCache.NoSlidingExpiration
            };

            cache.Add(cacheKey, entry, cacheItemPolicy);
        }
 public T Get <T>(string key, Func <T> loader)
 {
     if (!_cache.Contains(key))
     {
         _cache.Add(key, loader(), DateTimeOffset.UtcNow.AddSeconds(_config.CacheDurationSeconds));
     }
     return((T)_cache.GetCacheItem(key).Value);
 }
        public Task Set(Guid id, AggregateRoot aggregate)
        {
#if NET452
            _cache.Add(id.ToString(), aggregate, _policyFactory.Invoke());
#else
            _cache.Set(id, aggregate, _cacheOptions);
#endif
            return(Task.FromResult(0));
        }
        public void Insert <T>(string key, T value, TimeSpan expiration)
        {
            var cacheItemPolicy = new CacheItemPolicy
            {
                AbsoluteExpiration = DateTime.Now + expiration
            };

            _cache.Add(key, value, cacheItemPolicy);
        }
        public static void StoreTokenInCache(string tokenId)
        {
            var cacheItemPolicy = new CacheItemPolicy()
            {
                AbsoluteExpiration = DateTime.Now.AddMinutes(30)
            };

            _cache.Add(_key, tokenId, cacheItemPolicy);
        }
Beispiel #18
0
		public void TestBasic()
		{
			var memoryCache = new MemoryCache("Foo");
			var policy = new CacheItemPolicy();
			memoryCache.AddOrGetExisting("Pop", 123, DateTimeOffset.MaxValue);
			memoryCache.AddOrGetExisting("Top", "Gun", DateTimeOffset.MaxValue);

			memoryCache.Add("Pop", 12, DateTime.MaxValue);

			Assert.AreEqual("Gun", memoryCache.Get("Top"));
			Assert.AreEqual(123, memoryCache.Get("Pop"));
		}
        public void Save <T>(T aggregate, int?expectedVersion = null)
            where T : AggregateRoot
        {
            var idstring = aggregate.Id.ToString();

            try
            {
                lock (_locks.GetOrAdd(idstring, _ => new object()))
                {
                    if (aggregate.Id != Guid.Empty && !IsTracked(aggregate.Id))
                    {
                        _cache.Add(idstring, aggregate, _policyFactory.Invoke());
                    }
                    _repository.Save(aggregate, expectedVersion);
                }
            }
            catch (Exception)
            {
                _cache.Remove(idstring);
                throw;
            }
        }
Beispiel #20
0
 public override void Add <T>(object objectToCache, string key, double cacheDuration)
 {
     if (objectToCache == null)
     {
         _cache.Remove(key);
     }
     else
     {
         _cache.Add(new CacheItem(key, objectToCache), new CacheItemPolicy()
         {
             AbsoluteExpiration = DateTime.Now.AddMinutes(cacheDuration)
         });
     }
 }
        public void TestCount()
        {
            MemoryCache memoryCount = new MemoryCache("count");

            Desenvolvedor dev = new Desenvolvedor();
            dev.Nome = "Ninja";
            dev.Linguagem = "C#";
            dev.AnosExperiencia = 15;

            CacheItemPolicy policy = new CacheItemPolicy();
            policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(2);

            memoryCount.Add("devRemove", dev, policy);

            Assert.AreEqual(1, memoryCount.GetCount());
        }
Beispiel #22
0
        /// <summary>
        /// Stores an object in the cache.
        /// </summary>
        /// <param name="cacheKey">The cache key to store the object against.</param>
        /// <param name="data">The data to store against the key.</param>
        /// <param name="duration">The duration, in seconds, to cache the data for.</param>
        public virtual void SetCachedObject <T>(string cacheKey, T data, int duration)
        {
            // ReSharper disable once ConvertIfStatementToNullCoalescingExpression type conflict
            if (data == null)
            {
                _cache.Add(cacheKey, nullReference, DateTime.Now.AddSeconds(duration));
            }
            else
            {
                var cacheItemPolicy = new CacheItemPolicy()                 //TODO to settings
                {
                    SlidingExpiration = TimeSpan.FromSeconds(duration)
                };

                _cache.Set(cacheKey, data, cacheItemPolicy);
            }
        }
        public void RedisNotificationBus_WhenInvalidation_ShouldDisposeMonitor()
        {
            var lcache = new MemoryCache(Guid.NewGuid().ToString());
            var bus = new RedisNotificationBus("localhost:6379", new InvalidationSettings() { TargetCache = lcache, InvalidationStrategy = InvalidationStrategyType.ChangeMonitor });
            bus.Connection = this.MockOfConnection.Object;
            var monitor = new RedisChangeMonitor(bus.Notifier, "mykey");
            lcache.Add("mykey", DateTime.UtcNow, new CacheItemPolicy() { AbsoluteExpiration = DateTime.UtcNow.AddDays(1), ChangeMonitors = { monitor } });

            bus.Start();

            //act
            this.NotificationEmitter(Constants.DEFAULT_INVALIDATION_CHANNEL, "mykey");

            //assert
            Assert.False(lcache.Contains("mykey"));
            Assert.True(monitor.IsDisposed);
        }
 public static void Set(string key, object o, int timeout)
 {
     System.Runtime.Caching.MemoryCache cache = System.Runtime.Caching.MemoryCache.Default;
     cache.Add(TransformKey(key), o, DateTime.Now.AddMinutes(timeout));
 }
Beispiel #25
0
 /// <summary>
 /// Doing MemoryCaching
 /// </summary>
 /// <param name="key">Cache key</param>
 /// <param name="value">Cache value</param>
 /// <param name="cacheTime">Cache time (in minute)</param>
 public static void AddToCache(string key, object value, int cacheTime)
 {
     cache.Add(key, value, DateTime.Now.AddMinutes(cacheTime));
 }
        public void when_reading_entity_then_rehydrates()
        {
            var newEvents = new IVersionedEvent[]
                             {
                                 new TestEvent { SourceId = id, Version = 2, Foo = "Baz" }                              
                             };
            var serialized = newEvents.Select(x => new EventData { Version = x.Version, Payload = Serialize(x) });
            this.id = Guid.NewGuid();
            var eventStore = new Mock<IEventStore>();
            this.memento = Mock.Of<IMemento>(x => x.Version == 1);
            var cache = new MemoryCache(Guid.NewGuid().ToString());
            cache.Add("TestOriginatorEntity_" + id.ToString(), new Tuple<IMemento, DateTime?>(this.memento, null), DateTimeOffset.UtcNow.AddMinutes(10));

            eventStore.Setup(x => x.Load(It.IsAny<string>(), 2)).Returns(serialized);
            var sut = new AzureEventSourcedRepository<TestOriginatorEntity>(eventStore.Object, Mock.Of<IEventStoreBusPublisher>(), new JsonTextSerializer(), new StandardMetadataProvider(), cache);

            var entity = sut.Find(id);

            Assert.NotNull(entity);
            Assert.Equal(id, entity.Id);
            Assert.Equal(memento, entity.Memento);
            Assert.Equal(newEvents, entity.History, new TestEventComparer());
        }
 private static CacheItem CreateCacheItemAndAdd(MemoryCache target, string cacheKey, RedisChangeMonitor monitor = null)
 {
     var cacheItem = new CacheItem(cacheKey, DateTime.Now);
     var policy = new CacheItemPolicy
     {
         AbsoluteExpiration = DateTime.UtcNow.AddDays(1)
     };
     if (monitor != null)
         policy.ChangeMonitors.Add(monitor);
     target.Add(cacheItem, policy);
     return cacheItem;
 }
Beispiel #28
0
		public void TestCacheExpiryOrdering ()
		{
			var config = new NameValueCollection ();
			config["cacheMemoryLimitMegabytes"] = 0.ToString ();
			config["physicalMemoryLimitPercentage"] = 100.ToString ();
			config["__MonoEmulateOneCPU"] = true.ToString ();

			// it appears that pollingInterval does nothing, so we set the Mono timer as well
			config["pollingInterval"] = new TimeSpan (0, 0, 1).ToString ();
			config["__MonoTimerPeriod"] = 1.ToString ();

			using (var mc = new MemoryCache ("TestCacheExpiryOrdering",  config)) {
				Assert.AreEqual (0, mc.GetCount (), "#CEO1");

				// add long lived items into the cache first
				for (int i = 0; i < 100; i++) {
					var cip = new CacheItemPolicy ();
					cip.SlidingExpiration = new TimeSpan (0, 0, 10);
					mc.Add ("long-" + i, i, cip);
				}

				Assert.AreEqual (100, mc.GetCount (), "#CEO2");

				// add shorter lived items into the cache, these should expire first
				for (int i = 0; i < 100; i++) {
					var cip = new CacheItemPolicy ();
					cip.SlidingExpiration = new TimeSpan(0, 0, 1);
					mc.Add ("short-" + i, i, cip);
				}

				Assert.AreEqual (200, mc.GetCount (), "#CEO3");

				global::System.Threading.Thread.Sleep (4 * 1000);

				Assert.AreEqual (100, mc.GetCount (), "#CEO4");
			}
		}
Beispiel #29
0
		public void TestExpiredGetValues ()
		{
			var config = new NameValueCollection ();
			config["cacheMemoryLimitMegabytes"] = 0.ToString ();
			config["physicalMemoryLimitPercentage"] = 100.ToString ();
			config["__MonoEmulateOneCPU"] = true.ToString ();

			// it appears that pollingInterval does nothing, so we set the Mono timer as well
			config["pollingInterval"] = new TimeSpan (0, 0, 10).ToString ();
			config["__MonoTimerPeriod"] = 10.ToString ();
			
			using (var mc = new MemoryCache ("TestExpiredGetValues",  config)) {
				Assert.AreEqual (0, mc.GetCount (), "#EGV1");

				var keys = new List<string> ();

				// add some short duration entries
				for (int i = 0; i < 10; i++) {
					var key = "short-" + i;
					var expireAt = DateTimeOffset.Now.AddSeconds (1);
					mc.Add (key, i.ToString (), expireAt);

					keys.Add (key);
				}

				Assert.AreEqual (10, mc.GetCount (), "#EGV2");

				global::System.Threading.Thread.Sleep (1000);

				// we have waited but the items won't be expired by the timer since it wont have fired yet
				Assert.AreEqual (10, mc.GetCount (), "#EGV3");

				// calling GetValues() will expire the items since we are now past their expiresAt
				mc.GetValues (keys);

				Assert.AreEqual (0, mc.GetCount (), "#EGV4");
			}
		}
Beispiel #30
0
		public void TestCacheShrink ()
		{
			const int HEAP_RESIZE_THRESHOLD = 8192 + 2;
			const int HEAP_RESIZE_SHORT_ENTRIES = 2048;
			const int HEAP_RESIZE_LONG_ENTRIES = HEAP_RESIZE_THRESHOLD - HEAP_RESIZE_SHORT_ENTRIES;			
			
			var config = new NameValueCollection ();
			config["cacheMemoryLimitMegabytes"] = 0.ToString ();
			config["physicalMemoryLimitPercentage"] = 100.ToString ();
			config["__MonoEmulateOneCPU"] = true.ToString ();

			// it appears that pollingInterval does nothing, so we set the Mono timer as well
			config["pollingInterval"] = new TimeSpan (0, 0, 1).ToString ();
			config["__MonoTimerPeriod"] = 1.ToString ();
			
			using (var mc = new MemoryCache ("TestCacheShrink",  config)) {	
				Assert.AreEqual (0, mc.GetCount (), "#CS1");
							
				// add some short duration entries
				for (int i = 0; i < HEAP_RESIZE_SHORT_ENTRIES; i++) {
					var expireAt = DateTimeOffset.Now.AddSeconds (3);
					mc.Add ("short-" + i, i.ToString (), expireAt);
				}
				
				Assert.AreEqual (HEAP_RESIZE_SHORT_ENTRIES, mc.GetCount (), "#CS2");
							
				// add some long duration entries				
				for (int i = 0; i < HEAP_RESIZE_LONG_ENTRIES; i++) {
					var expireAt = DateTimeOffset.Now.AddSeconds (12);
					mc.Add ("long-" + i, i.ToString (), expireAt);
				}															
				
				Assert.AreEqual (HEAP_RESIZE_LONG_ENTRIES + HEAP_RESIZE_SHORT_ENTRIES, mc.GetCount(), "#CS3");
				
				// wait for the cache thread to expire the short duration items, this will also shrink the size of the cache
				global::System.Threading.Thread.Sleep (5 * 1000);
				
				Assert.AreEqual (HEAP_RESIZE_LONG_ENTRIES, mc.GetCount (), "#CS4");	
				
				// add some new items into the cache, this will grow the cache again
				for (int i = 0; i < HEAP_RESIZE_LONG_ENTRIES; i++) {				
					mc.Add("final-" + i, i.ToString (), DateTimeOffset.Now.AddSeconds (4));
				}			
				
				Assert.AreEqual (HEAP_RESIZE_LONG_ENTRIES + HEAP_RESIZE_LONG_ENTRIES, mc.GetCount (), "#CS5");	
			}
		}
Beispiel #31
0
 public bool Add <T>(string key, T val, TimeSpan expiresIn) => FBackend.Add(key, val, new CacheItemPolicy
 {
     AbsoluteExpiration = ObjectCache.InfiniteAbsoluteExpiration,
     SlidingExpiration  = expiresIn
 });
		public void TestCacheSliding ()
		{    
			var config = new NameValueCollection ();
			config["cacheMemoryLimitMegabytes"] = 0.ToString ();
			config["physicalMemoryLimitPercentage"] = 100.ToString ();
			config["pollingInterval"] = new TimeSpan (0, 0, 1).ToString ();

			using (var mc = new MemoryCache ("TestCacheSliding",  config)) {
				Assert.AreEqual (0, mc.GetCount (), "#CSL1");

				var cip = new CacheItemPolicy();
				// The sliding expiration timeout has to be greater than 1 second because
				// .NET implementation ignores timeouts updates smaller than
				// CacheExpires.MIN_UPDATE_DELTA which is equal to 1.
				cip.SlidingExpiration = new TimeSpan (0, 0, 2);
				mc.Add("slidingtest", "42", cip);

				mc.Add("expire1", "1", cip);
				mc.Add("expire2", "2", cip);
				mc.Add("expire3", "3", cip);
				mc.Add("expire4", "4", cip);
				mc.Add("expire5", "5", cip);

				Assert.AreEqual (6, mc.GetCount (), "#CSL2");

				for (int i = 0; i < 50; i++) {
					global::System.Threading.Thread.Sleep (100);

					var item = mc.Get ("slidingtest");
					Assert.AreNotEqual (null, item, "#CSL3-" + i);
				}

				Assert.IsNull (mc.Get ("expire1"), "#CSL4-1");
				Assert.IsNull (mc.Get ("expire2"), "#CSL4-2");
				Assert.IsNull (mc.Get ("expire3"), "#CSL4-3");
				Assert.IsNull (mc.Get ("expire4"), "#CSL4-4");
				Assert.IsNull (mc.Get ("expire5"), "#CSL4-5");
				Assert.AreEqual (1, mc.GetCount (), "#CSL4");

				global::System.Threading.Thread.Sleep (4 * 1000);

				Assert.IsNull (mc.Get ("slidingtest"), "#CSL5a");
				Assert.AreEqual (0, mc.GetCount (), "#CSL5");
			}
		}
Beispiel #33
0
		public void TestCacheSliding ()
		{    
			var config = new NameValueCollection ();
			config["cacheMemoryLimitMegabytes"] = 0.ToString ();
			config["physicalMemoryLimitPercentage"] = 100.ToString ();
			config["__MonoEmulateOneCPU"] = true.ToString ();

			// it appears that pollingInterval does nothing, so we set the Mono timer as well
			config["pollingInterval"] = new TimeSpan (0, 0, 1).ToString ();
			config["__MonoTimerPeriod"] = 1.ToString ();

			using (var mc = new MemoryCache ("TestCacheSliding",  config)) {
				Assert.AreEqual (0, mc.GetCount (), "#CSL1");

				var cip = new CacheItemPolicy();
				cip.SlidingExpiration = new TimeSpan (0, 0, 1);
				mc.Add("slidingtest", "42", cip);

				mc.Add("expire1", "1", cip);
				mc.Add("expire2", "2", cip);
				mc.Add("expire3", "3", cip);
				mc.Add("expire4", "4", cip);
				mc.Add("expire5", "5", cip);

				Assert.AreEqual (6, mc.GetCount (), "#CSL2");

				for (int i = 0; i < 50; i++) {
					global::System.Threading.Thread.Sleep (100);

					var item = mc.Get ("slidingtest");
					Assert.AreNotEqual (null, item, "#CSL3-" + i);
				}

				Assert.AreEqual (1, mc.GetCount (), "#CSL4");

				global::System.Threading.Thread.Sleep (4 * 1000);

				Assert.AreEqual (0, mc.GetCount (), "#CSL5");
			}
		}
Beispiel #34
0
 /// <summary>
 /// Set Key  and value on the MemoryCache server cache
 /// </summary>
 /// <typeparam name="T">Type of object</typeparam>
 /// <param name="key">Key of object</param>
 /// <returns>object</returns>
 public override void Set <T>(string key, T value)
 {
     Cache.Add(key, value, options);
 }
 /// <summary>
 /// Add new object to the cache
 /// </summary>
 /// <param name="key"></param>
 /// <param name="data"></param>
 public void SetOnly(string key, object data)
 {
     _cache.Add(key, data, DateTimeOffset.UtcNow.AddMinutes(30));
 }