Ejemplo n.º 1
0
 /// <summary>
 /// Add the object into MemoryCache
 /// </summary>
 /// <param name="persistenceCacheStackEntity"></param>
 /// <returns></returns>
 protected virtual bool AddItem(PersistenceCacheStackEntity persistenceCacheStackEntity)
 {
     try
     {
         var cacheItem = new CacheItem(persistenceCacheStackEntity.Key, persistenceCacheStackEntity);
         lock (padlock)
         {
             if (persistenceCacheStackEntity.Expiration == null)
             {
                 cache.Set(cacheItem, new CacheItemPolicy());
             }
             else
             {
                 // if it is required a cache expiration
                 cache.Set(cacheItem, new CacheItemPolicy()
                 {
                     AbsoluteExpiration = persistenceCacheStackEntity.Expiration.Value
                 });
             }
         }
         return(true);
     }
     catch (Exception)
     {
         return(false);
     }
 }
Ejemplo n.º 2
0
        public void TestAddItem()
        {
            var persistenceCacheStackEntity = new PersistenceCacheStackEntity("test", new object(), null);
            var addResult = new RedisWrapper().Push(persistenceCacheStackEntity);

            Assert.IsTrue(addResult);
        }
        public void TestSynchFromRedis()
        {
            var testClass = new UnitTestClass()
            {
                TestDescription = "TestSynchFromRedis",
                TestId          = 4
            };

            var persistenceCacheStackEntity = new PersistenceCacheStackEntity("TestSynchFromRedis", testClass, null);

            var redisWrapper = new RedisWrapper();

            // add fake object into Redis
            var addResult = redisWrapper.Push(persistenceCacheStackEntity);

            Assert.IsTrue(addResult);

            var objectCached = redisWrapper.Get(persistenceCacheStackEntity.Key);

            Assert.IsNotNull(objectCached);

            // synch from Redis
            var persistenceCacheStack = new PersistenceCacheStackClient <UnitTestClass>(true);

            var obj = persistenceCacheStack.GetItem("TestSynchFromRedis");

            Assert.IsNotNull(obj);
            Assert.IsTrue(obj.TestId == 4);
        }
        /// <summary>
        /// Add item into MemoryCache and Redis for persistence
        /// </summary>
        /// <param name="PersistenceCacheStackEntity"></param>
        /// <returns></returns>
        public bool AddItem(PersistenceCacheStackEntity persistenceCacheStackEntity)
        {
            var resultInMemory = GlobalCachingProvider.Instance.AddItem(persistenceCacheStackEntity);

            if (true == resultInMemory)
            {
                this.taskFactory.StartNew(() => this.redisWrapper.Push(persistenceCacheStackEntity));
                return(true);
            }
            return(false);
        }
Ejemplo n.º 5
0
        public void TestGetItem()
        {
            var persistenceCacheStackEntity = new PersistenceCacheStackEntity("test", new object(), null);

            var redisWrapper = new RedisWrapper();

            var addResult = redisWrapper.Push(persistenceCacheStackEntity);

            Assert.IsTrue(addResult);

            var objectCached = redisWrapper.Get(persistenceCacheStackEntity.Key);

            Assert.IsNotNull(objectCached);
        }
        public void TestAddItem()
        {
            var testClass = new UnitTestClass()
            {
                TestDescription = "test1",
                TestId          = 1
            };

            var persistenceCacheStackEntity = new PersistenceCacheStackEntity("test1", testClass, null);

            var addResult = GlobalCachingProvider.Instance.AddItem(persistenceCacheStackEntity);

            Assert.IsTrue(addResult);
        }
        /// <summary>
        /// Update the PersistenceCacheStackEntity object into MemoryCache and Redis
        /// </summary>
        /// <param name="PersistenceCacheStackEntity"></param>
        /// <returns></returns>
        public bool UpdateItem(PersistenceCacheStackEntity persistenceCacheStackEntity)
        {
            var objCached = GlobalCachingProvider.Instance.GetItem(persistenceCacheStackEntity.Key, true);

            if (objCached != null)
            {
                var resultInMemory = GlobalCachingProvider.Instance.AddItem(persistenceCacheStackEntity);
                if (true == resultInMemory)
                {
                    this.taskFactory.StartNew(() => this.redisWrapper.Update(persistenceCacheStackEntity));
                }
                return(resultInMemory);
            }
            return(false);
        }
        public void TestGetItem()
        {
            var testClass = new UnitTestClass()
            {
                TestDescription = "test2",
                TestId          = 2
            };

            var persistenceCacheStackEntity = new PersistenceCacheStackEntity("test2", testClass, null);

            var addResult = GlobalCachingProvider.Instance.AddItem(persistenceCacheStackEntity);

            Assert.IsTrue(addResult);

            var objectCached = GlobalCachingProvider.Instance.GetItem(persistenceCacheStackEntity.Key, false);

            Assert.IsNotNull(objectCached);
            Assert.AreEqual(objectCached.Key, "test2");
        }
        /// <summary>
        /// Check the current state of the object into Redis and eventually sync the memory cache
        /// </summary>
        private void CheckExternalsUpdates(string key, PersistenceCacheStackEntity persistenceCacheStackEntity)
        {
            var objRedis = redisWrapper.Get(key);

            if (objRedis != null)
            {
                if (persistenceCacheStackEntity == null)
                {
                    // another node has added the object with key into redis, we must therefore add it into the MemoryCache
                    GlobalCachingProvider.Instance.AddItem(objRedis);
                }
                else if (!objRedis.Equals(persistenceCacheStackEntity))
                {
                    // another node has updated the object, we must therefore update it into the MemoryCache
                    GlobalCachingProvider.Instance.GetItem(key, true);
                    GlobalCachingProvider.Instance.AddItem(objRedis);
                }
            }
            else
            {
                // another node has deleted the key from Redis, we must therefore remove it from the MemoryCache
                GlobalCachingProvider.Instance.GetItem(key, true);
            }
        }
        public void TestUpdateItem()
        {
            var testClass = new UnitTestClass()
            {
                TestDescription = "test4",
                TestId          = 4
            };

            var persistenceCacheStackEntity = new PersistenceCacheStackEntity("test4", testClass, null);

            var addResult = GlobalCachingProvider.Instance.AddItem(persistenceCacheStackEntity);

            Assert.IsTrue(addResult);

            var objectCached = GlobalCachingProvider.Instance.GetItem(persistenceCacheStackEntity.Key, false);

            Assert.AreEqual(objectCached.Key, "test4");

            testClass.TestDescription = "update_test4";

            persistenceCacheStackEntity = new PersistenceCacheStackEntity("test4", testClass, null);

            var updateResult = GlobalCachingProvider.Instance.AddItem(persistenceCacheStackEntity);

            Assert.IsTrue(updateResult);

            var updatedObject = GlobalCachingProvider.Instance.GetItem(persistenceCacheStackEntity.Key, false);

            Assert.IsNotNull(updatedObject);
            Assert.IsNotNull(updatedObject.Object);

            var updateTestClass = (UnitTestClass)updatedObject.Object;

            Assert.IsNotNull(updateTestClass);
            Assert.IsTrue(updateTestClass.TestDescription == "update_test4");
        }
Ejemplo n.º 11
0
 /// <summary>
 /// Update the PersistenceCacheStackEntity object
 /// </summary>
 /// <param name="pCacheStackEntity"></param>
 /// <returns></returns>
 public bool Update(PersistenceCacheStackEntity pCacheStackEntity)
 {
     return(pCacheStackEntity != null && (pCacheStackEntity?.Expiration != null
                ? RedisAccess.Instance.RedisCacheClient.Replace(pCacheStackEntity.Key, pCacheStackEntity, pCacheStackEntity.Expiration.Value)
                : RedisAccess.Instance.RedisCacheClient.Replace(pCacheStackEntity.Key, pCacheStackEntity)));
 }
 /// <summary>
 /// Add the object into MemoryCache
 /// </summary>
 /// <param name="persistenceCacheStackEntity"></param>
 /// <returns></returns>
 public new bool AddItem(PersistenceCacheStackEntity persistenceCacheStackEntity)
 {
     return(base.AddItem(persistenceCacheStackEntity));
 }