public void AddWithExistingTagTest() { var provider = new MemoryCacheProvider(); string key = "AddWithExistingTagTest" + DateTime.Now.Ticks; string[] tags = new[] { "a", "b" }; var cacheKey = new CacheKey(key, tags); var value = "Test Value " + DateTime.Now; var cachePolicy = new CachePolicy(); bool result = provider.Add(cacheKey, value, cachePolicy); result.Should().BeTrue(); // make sure cache key is in underlying MemoryCache var cacheTag = new CacheTag("a"); string tagKey = MemoryCacheProvider.GetTagKey(cacheTag); tagKey.Should().NotBeNullOrEmpty(); var cachedTag = MemoryCache.Default.Get(tagKey); cachedTag.Should().NotBeNull(); // add second value with same tag string key2 = "AddWithExistingTagTest2" + DateTime.Now.Ticks; string[] tags2 = new[] { "a", "c" }; var cacheKey2 = new CacheKey(key2, tags2); var value2 = "Test Value 2 " + DateTime.Now; var cachePolicy2 = new CachePolicy(); bool result2 = provider.Add(cacheKey2, value2, cachePolicy2); result2.Should().BeTrue(); // tag 'a' should have same value var cachedTag2 = MemoryCache.Default.Get(tagKey); cachedTag2.Should().NotBeNull(); cachedTag2.Should().Be(cachedTag); }
//[Fact] public void ExpireTest() { var cacheManager = new CacheManager(); string key = "ExpireTest" + DateTime.Now.Ticks; var tags = new[] { "a", "b" }; var cacheKey = new CacheKey(key, tags); var value = "Test Value " + DateTime.Now; var cachePolicy = new CachePolicy(); bool result = cacheManager.Add(cacheKey, value, cachePolicy); result.Should().BeTrue(); // add second value with same tag string key2 = "ExpireTest2" + DateTime.Now.Ticks; var tags2 = new[] { "a", "c" }; var cacheKey2 = new CacheKey(key2, tags2); var value2 = "Test Value 2 " + DateTime.Now; var cachePolicy2 = new CachePolicy(); bool result2 = cacheManager.Add(cacheKey2, value2, cachePolicy2); result2.Should().BeTrue(); // add third value with same tag string key3 = "ExpireTest3" + DateTime.Now.Ticks; var tags3 = new[] { "b", "c" }; var cacheKey3 = new CacheKey(key3, tags3); var value3 = "Test Value 3 " + DateTime.Now; var cachePolicy3 = new CachePolicy(); bool result3 = cacheManager.Add(cacheKey3, value3, cachePolicy3); result3.Should().BeTrue(); var cacheTag = new CacheTag("a"); string tagKey = MemoryCacheProvider.GetTagKey(cacheTag); tagKey.Should().NotBeNullOrEmpty(); var cachedTag = cacheManager.Get<object>(tagKey); cachedTag.Should().NotBeNull(); // expire actually just changes the value for tag key cacheManager.Expire(cacheTag); // allow flush System.Threading.Thread.Sleep(500); var expiredTag = cacheManager.Get<object>(tagKey); expiredTag.Should().NotBeNull(); expiredTag.Should().NotBe(cachedTag); // items should have been removed var expiredValue = cacheManager.Get<string>(cacheKey.Key); expiredValue.Should().BeNull(); var expiredValue2 = cacheManager.Get<string>(cacheKey2.Key); expiredValue2.Should().BeNull(); var expiredValue3 = cacheManager.Get<string>(cacheKey3.Key); expiredValue3.Should().NotBeNull(); }
public void AddWithTagsTest() { var provider = new MemoryCacheProvider(); string key = "AddWithTagsTest" + DateTime.Now.Ticks; string[] tags = new[] { "a", "b" }; var cacheKey = new CacheKey(key, tags); var value = "Test Value " + DateTime.Now; var cachePolicy = new CachePolicy(); bool result = provider.Add(cacheKey, value, cachePolicy); result.Should().BeTrue(); // look in underlying MemoryCache string innerKey = MemoryCacheProvider.GetKey(cacheKey); var cachedValue = MemoryCache.Default.Get(innerKey); cachedValue.Should().NotBeNull(); cachedValue.Should().Be(value); // make sure cache key is in underlying MemoryCache var cacheTag = new CacheTag("a"); string tagKey = MemoryCacheProvider.GetTagKey(cacheTag); tagKey.Should().NotBeNullOrEmpty(); var cachedTag = MemoryCache.Default.Get(tagKey); cachedTag.Should().NotBeNull(); }
public void KeyTest() { string key = DateTime.Now.Ticks.ToString(CultureInfo.InvariantCulture); var target = new CacheKey(key); target.Should().NotBeNull(); target.Key.Should().NotBeNull(); target.Key.Should().Be(key); }
public void CacheKeyConstructorTest1() { string key = string.Empty; var target = new CacheKey(key); target.Should().NotBeNull(); target.Key.Should().NotBeNull(); target.Key.Should().Be(string.Empty); }
/// <summary> /// Inserts a cache entry into the cache without overwriting any existing cache entry. /// </summary> /// <param name="cacheKey">A unique identifier for the cache entry.</param> /// <param name="value">The object to insert.</param> /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param> /// <returns> /// <c>true</c> if insertion succeeded, or <c>false</c> if there is an already an entry in the cache that has the same key as key. /// </returns> public bool Add(CacheKey cacheKey, object value, CachePolicy cachePolicy) { string key = GetKey(cacheKey); var item = new CacheItem(key, value); var policy = CreatePolicy(cacheKey, cachePolicy); var existing = MemoryCache.Default.AddOrGetExisting(item, policy); return existing.Value == null; }
public void AddTest() { var cacheManager = new CacheManager(); var cacheKey = new CacheKey("AddTest" + DateTime.Now.Ticks); var value = "Test Value " + DateTime.Now; var cachePolicy = new CachePolicy(); bool result = cacheManager.Add(cacheKey, value, cachePolicy); result.Should().BeTrue(); }
public void TagsTest() { string key = DateTime.Now.Ticks.ToString(CultureInfo.InvariantCulture); string[] tags = new[] { "a", "b" }; var target = new CacheKey(key, tags); target.Should().NotBeNull(); target.Key.Should().NotBeNull(); target.Key.Should().Be(key); target.Tags.Should().HaveCount(2); }
public void AddTest() { var provider = new MemoryCacheProvider(); var cacheKey = new CacheKey("AddTest" + DateTime.Now.Ticks); var value = "Test Value " + DateTime.Now; var cachePolicy = new CachePolicy(); bool result = provider.Add(cacheKey, value, cachePolicy); result.Should().BeTrue(); // look in underlying MemoryCache string innerKey = MemoryCacheProvider.GetKey(cacheKey); var cachedValue = MemoryCache.Default.Get(innerKey); cachedValue.Should().NotBeNull(); cachedValue.Should().Be(value); }
/// <summary> /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned by <paramref name="valueFactory"/>. /// </summary> /// <param name="cacheKey">A unique identifier for the cache entry.</param> /// <param name="valueFactory">The function used to generate a value to insert into cache.</param> /// <param name="cachePolicy">A <see cref="CachePolicy"/> that contains eviction details for the cache entry.</param> /// <returns> /// The value for the key. This will be either the existing value for the key if the key is already in the cache, /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the cache. /// </returns> public object GetOrAdd(CacheKey cacheKey, Func<CacheKey, object> valueFactory, CachePolicy cachePolicy) { string key = GetKey(cacheKey); if (MemoryCache.Default.Contains(key)) { Debug.WriteLine("Cache Hit : " + key); return MemoryCache.Default.Get(key); } Debug.WriteLine("Cache Miss: " + key); // get value and add to cache object value = valueFactory(cacheKey); if (Add(cacheKey, value, cachePolicy)) return value; // add failed return null; }
/// <summary> /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned by <paramref name="valueFactory"/>. /// </summary> /// <param name="cacheKey">A unique identifier for the cache entry.</param> /// <param name="valueFactory">The function used to generate a value to insert into cache.</param> /// <param name="cachePolicy">A <see cref="CachePolicy"/> that contains eviction details for the cache entry.</param> /// <returns> /// The value for the key. This will be either the existing value for the key if the key is already in the cache, /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the cache. /// </returns> public object GetOrAdd(CacheKey cacheKey, Func<CacheKey, object> valueFactory, CachePolicy cachePolicy) { var key = GetKey(cacheKey); var cachedResult = MemoryCache.Default.Get(key); if (cachedResult != null) { Debug.WriteLine("Cache Hit : " + key); return cachedResult; } Debug.WriteLine("Cache Miss: " + key); // get value and add to cache, not bothered // if it succeeds or not just rerturn the value var value = valueFactory(cacheKey); this.Add(cacheKey, value, cachePolicy); return value; }
public void GetOrAddTest() { var provider = new MemoryCacheProvider(); var cacheKey = new CacheKey("GetOrAddTest" + DateTime.Now.Ticks); var value = "Test Value " + DateTime.Now; var cachePolicy = new CachePolicy(); int callCount = 0; Func<CacheKey, object> valueFactory = k => { callCount++; return value; }; var result = provider.GetOrAdd(cacheKey, valueFactory, cachePolicy); result.Should().Be(value); callCount.Should().Be(1); // look in underlying MemoryCache string innerKey = MemoryCacheProvider.GetKey(cacheKey); var cachedValue = MemoryCache.Default.Get(innerKey); cachedValue.Should().NotBeNull(); cachedValue.Should().Be(value); callCount = 0; var result2 = provider.GetOrAdd(cacheKey, valueFactory, cachePolicy); result2.Should().Be(value); callCount.Should().Be(0); }
public void SetTest() { var cacheManager = new CacheManager(); var cacheKey = new CacheKey("SetTest" + DateTime.Now.Ticks); var value = "Set Value " + DateTime.Now; var cachePolicy = new CachePolicy(); cacheManager.Set(cacheKey, value, cachePolicy); var cachedValue = cacheManager.Get(cacheKey.Key); cachedValue.Should().NotBeNull(); cachedValue.Should().Be(value); var value2 = "Set Value " + DateTime.Now; cacheManager.Set(cacheKey, value2, cachePolicy); var cachedValue2 = cacheManager.Get(cacheKey.Key); cachedValue2.Should().NotBeNull(); cachedValue2.Should().Be(value2); }
public void ExpireTest() { var cache = MemoryCache.Default; // purge all values foreach (KeyValuePair<string, object> pair in cache) cache.Remove(pair.Key); var provider = new MemoryCacheProvider(); string key = "ExpireTest" + DateTime.Now.Ticks; var tags = new[] { "a", "b" }; var cacheKey = new CacheKey(key, tags); var value = "Test Value " + DateTime.Now; var cachePolicy = new CachePolicy(); bool result = provider.Add(cacheKey, value, cachePolicy); result.Should().BeTrue(); // add second value with same tag string key2 = "ExpireTest2" + DateTime.Now.Ticks; var tags2 = new[] { "a", "c" }; var cacheKey2 = new CacheKey(key2, tags2); var value2 = "Test Value 2 " + DateTime.Now; var cachePolicy2 = new CachePolicy(); bool result2 = provider.Add(cacheKey2, value2, cachePolicy2); result2.Should().BeTrue(); // add third value with same tag string key3 = "ExpireTest3" + DateTime.Now.Ticks; var tags3 = new[] { "b", "c" }; var cacheKey3 = new CacheKey(key3, tags3); var value3 = "Test Value 3 " + DateTime.Now; var cachePolicy3 = new CachePolicy(); bool result3 = provider.Add(cacheKey3, value3, cachePolicy3); result3.Should().BeTrue(); var cacheTag = new CacheTag("a"); string tagKey = MemoryCacheProvider.GetTagKey(cacheTag); tagKey.Should().NotBeNullOrEmpty(); // underlying cache cache.GetCount().Should().Be(6); var cachedTag = cache.Get(tagKey); cachedTag.Should().NotBeNull(); System.Threading.Thread.Sleep(500); // expire actually just changes the value for tag key provider.Expire(cacheTag); var expiredTag = cache.Get(tagKey); expiredTag.Should().NotBeNull(); expiredTag.Should().NotBe(cachedTag); // items should have been removed var expiredValue = provider.Get<string>(cacheKey); expiredValue.Should().BeNull(); var expiredValue2 = provider.Get<string>(cacheKey2); expiredValue2.Should().BeNull(); var expiredValue3 = provider.Get<string>(cacheKey3); expiredValue3.Should().NotBeNull(); cache.GetCount().Should().Be(4); }
public void GetTest() { var provider = new MemoryCacheProvider(); var cacheKey = new CacheKey("GetTest" + DateTime.Now.Ticks); var value = "Get Value " + DateTime.Now; var cachePolicy = new CachePolicy(); bool result = provider.Add(cacheKey, value, cachePolicy); result.Should().BeTrue(); var existing = provider.Get<string>(cacheKey); existing.Should().NotBeNull(); existing.Should().BeSameAs(value); }
/// <summary> /// Inserts a cache entry into the cache overwriting any existing cache entry. /// </summary> /// <param name="cacheKey">A unique identifier for the cache entry.</param> /// <param name="value">The object to insert.</param> /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param> public virtual void Set(CacheKey cacheKey, object value, CachePolicy cachePolicy) { var provider = ResolveProvider(); provider.Set(cacheKey, value, cachePolicy); }
/// <summary> /// Inserts a cache entry into the cache without overwriting any existing cache entry. /// </summary> /// <param name="key">A unique identifier for the cache entry.</param> /// <param name="value">The object to insert.</param> /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param> /// <returns> /// <c>true</c> if insertion succeeded, or <c>false</c> if there is an already an entry in the cache that has the same key as key. /// </returns> public bool Add(string key, object value, CachePolicy cachePolicy) { var cacheKey = new CacheKey(key); return Add(cacheKey, value, cachePolicy); }
/// <summary> /// Removes a cache entry from the cache. /// </summary> /// <param name="cacheKey">A unique identifier for the cache entry.</param> /// <returns>If the entry is found in the cache, the removed cache entry; otherwise, <see langword="null"/>.</returns> public virtual object Remove(CacheKey cacheKey) { var provider = ResolveProvider(); var item = provider.Remove(cacheKey); return item; }
/// <summary> /// Gets the cache value for the specified key that is already in the dictionary or the new value if the key was not in the dictionary. /// </summary> /// <param name="key">A unique identifier for the cache entry.</param> /// <param name="value">The object to insert.</param> /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param> /// <returns> /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, /// or the new value if the key was not in the dictionary. /// </returns> public object GetOrAdd(string key, object value, CachePolicy cachePolicy) { var cacheKey = new CacheKey(key); return GetOrAdd(cacheKey, value, cachePolicy); }
public void GetTest() { var cacheManager = new CacheManager(); var cacheKey = new CacheKey("GetTest" + DateTime.Now.Ticks); var value = "Get Value " + DateTime.Now; var cachePolicy = new CachePolicy(); bool result = cacheManager.Add(cacheKey, value, cachePolicy); result.Should().BeTrue(); var existing = cacheManager.Get(cacheKey.Key); existing.Should().NotBeNull(); existing.Should().BeSameAs(value); }
/// <summary> /// Removes a cache entry from the cache. /// </summary> /// <param name="key">A unique identifier for the cache entry.</param> /// <returns>If the entry is found in the cache, the removed cache entry; otherwise, <see langword="null"/>.</returns> public object Remove(string key) { var cacheKey = new CacheKey(key); return Remove(cacheKey); }
/// <summary> /// Inserts a cache entry into the cache without overwriting any existing cache entry. /// </summary> /// <param name="cacheKey">A unique identifier for the cache entry.</param> /// <param name="value">The object to insert.</param> /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param> /// <returns> /// <c>true</c> if insertion succeeded, or <c>false</c> if there is an already an entry in the cache that has the same key as key. /// </returns> public virtual bool Add(CacheKey cacheKey, object value, CachePolicy cachePolicy) { var provider = ResolveProvider(); return provider.Add(cacheKey, value, cachePolicy); }
/// <summary> /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned by <paramref name="valueFactory"/>. /// </summary> /// <param name="key">A unique identifier for the cache entry.</param> /// <param name="valueFactory">The function used to generate a value to insert into cache.</param> /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param> /// <returns> /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the dictionary. /// </returns> public object GetOrAdd(string key, Func<string, object> valueFactory, CachePolicy cachePolicy) { var cacheKey = new CacheKey(key); return GetOrAdd(cacheKey, valueFactory, cachePolicy); }
/// <summary> /// Gets the cache value for the specified key that is already in the dictionary or the new value if the key was not in the dictionary. /// </summary> /// <param name="key">A unique identifier for the cache entry.</param> /// <param name="value">The object to insert.</param> /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param> /// <returns> /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, /// or the new value if the key was not in the dictionary. /// </returns> public object GetOrAdd(CacheKey key, object value, CachePolicy cachePolicy) { return GetOrAdd(key, k => value, cachePolicy); }
public void CreateChangeMonitorTest() { string key = DateTime.Now.Ticks.ToString(CultureInfo.InvariantCulture); string[] tags = new[] { "a", "b" }; var cacheKey = new CacheKey(key, tags); cacheKey.Should().NotBeNull(); var monitor = MemoryCacheProvider.CreateChangeMonitor(cacheKey); monitor.Should().NotBeNull(); monitor.CacheKeys.Should().HaveCount(2); var cacheTag = new CacheTag("a"); string tagKey = MemoryCacheProvider.GetTagKey(cacheTag); tagKey.Should().NotBeNullOrEmpty(); monitor.CacheKeys.Should().Contain(tagKey); }
/// <summary> /// Inserts a cache entry into the cache overwriting any existing cache entry. /// </summary> /// <param name="key">A unique identifier for the cache entry.</param> /// <param name="value">The object to insert.</param> /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param> public void Set(string key, object value, CachePolicy cachePolicy) { var cacheKey = new CacheKey(key); Set(cacheKey, value, cachePolicy); }
public void CreatePolicySlidingTest() { string key = DateTime.Now.Ticks.ToString(CultureInfo.InvariantCulture); string[] tags = new[] { "a", "b" }; var cacheKey = new CacheKey(key, tags); cacheKey.Should().NotBeNull(); var slidingExpiration = TimeSpan.FromMinutes(5); var cachePolicy = CachePolicy.WithSlidingExpiration(slidingExpiration); cachePolicy.Should().NotBeNull(); var policy = MemoryCacheProvider.CreatePolicy(cacheKey, cachePolicy); policy.Should().NotBeNull(); policy.SlidingExpiration.Should().Be(slidingExpiration); policy.ChangeMonitors.Should().NotBeNull(); policy.ChangeMonitors.Should().HaveCount(1); policy.ChangeMonitors.Should().ContainItemsAssignableTo<CacheEntryChangeMonitor>(); }
/// <summary> /// Gets the cache value for the specified key /// </summary> /// <param name="key">A unique identifier for the cache entry.</param> /// <returns>The cache value for the specified key, if the entry exists; otherwise, <see langword="null"/>.</returns> public virtual object Get(string key) { var cacheKey = new CacheKey(key); var provider = ResolveProvider(); var item = provider.Get(cacheKey); return item; }
/// <summary> /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned by <paramref name="valueFactory"/>. /// </summary> /// <param name="cacheKey">A unique identifier for the cache entry.</param> /// <param name="valueFactory">The function used to generate a value to insert into cache.</param> /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param> /// <returns> /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the dictionary. /// </returns> public virtual object GetOrAdd(CacheKey cacheKey, Func<CacheKey, object> valueFactory, CachePolicy cachePolicy) { var provider = ResolveProvider(); var item = provider.GetOrAdd(cacheKey, valueFactory, cachePolicy); return item; }
/// <summary> /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned asynchronously by <paramref name="valueFactory"/>. /// </summary> /// <param name="cacheKey">A unique identifier for the cache entry.</param> /// <param name="valueFactory">The asynchronous function used to generate a value to insert into cache.</param> /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param> /// <returns> /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the dictionary. /// </returns> public virtual Task<object> GetOrAddAsync(CacheKey cacheKey, Func<CacheKey, Task<object>> valueFactory, CachePolicy cachePolicy) { var provider = ResolveProvider(); var item = provider.GetOrAddAsync(cacheKey, valueFactory, cachePolicy); return item; }