public void AddOrUpdate_SuccessfullyUpdatesCache_ByReturningUpdatedValue()
{
//Arrange
CacheTestData data = new CacheTestData()
{
ExpectedValue = "2"
};
//Act
try
{
AddMembers(2);
//Test updating the value of the first key to 2, instead of the default 0.
_cache.AddOrUpdate(0, "2");
_cache.TryGetValue(0, out data.Value);
}
catch (Exception e)
{
data.Errors = e.Message;
}
//Assert
Assert.That(data.Errors, Is.Null.Or.Empty, $"Expected there to be no exceptions during update. Error: {data.Errors}.");
Assert.That(data.Value, Is.EqualTo(data.ExpectedValue), $"Expected value to be the updated value of {data.ExpectedValue}, not {data.Value}.");
}
/// <summary>
/// Adds (or replaces) an object to the specified cache context.
/// </summary>
/// <param name="context">The context to add the object to.</param>
/// <param name="key">The key used to retrieve the object.</param>
/// <param name="value">The object to be stored.</param>
/// <returns>false if the object was updated, true if the key was added.</returns>
/// <exception cref="System.Collections.Generic.KeyNotFoundException">Thrown when the specified context does not exist.</exception>
public static bool AddOrUpdate(string context, object key, object value)
{
readWriteLock.AcquireReaderLock(MAX_LOCK_WAIT);
try {
if (caches.ContainsKey(context))
{
ICache tmpCache = caches[context];
if (DefaultExpiryTime == 0)
{
return(tmpCache.AddOrUpdate(key, value));
}
else
{
if (tmpCache.Contains(key))
{
tmpCache.Remove(key);
}
return(tmpCache.AddOrUpdate(key, value, TimeSpan.FromSeconds(DefaultExpiryTime)));
}
}
else
{
throw new KeyNotFoundException("The context '" + context + "' does not exist.");
}
}
finally { readWriteLock.ReleaseReaderLock(); }
}
public void TestGettingValues()
{
// Try to get value that is not in the cache
found = cache.TryGetValue("invalid key", out val);
Assert.Null(val);
Assert.False(found);
// Add 4 values to the cache
cache.AddOrUpdate("one", 1);
cache.AddOrUpdate("two", 2);
cache.AddOrUpdate("three", 3);
cache.AddOrUpdate("four", 4);
// Try to get first element from the cache, make sure it exists there
found = cache.TryGetValue("one", out val);
Assert.True(val == 1);
Assert.True(found);
// Try to get second element, it also should be there
found = cache.TryGetValue("two", out val);
Assert.True(val == 2);
Assert.True(found);
// Try to get element that doesn't exist, make sure it's not there
found = cache.TryGetValue("five", out val);
Assert.Null(val);
Assert.False(found);
}
public static void TryGet_AddOrUpdateTwoValue_ReturnsLastValue(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "TestValue");
cache.AddOrUpdate(1, "TestValue1234");
var keyExists = cache.TryGet(1, out var value);
Assert.True(keyExists);
Assert.Equal("TestValue1234", value);
}
public void AddOrUpdate(TObject item)
{
TKey key = _keySelector.GetKey(item);
var previous = _cache.Lookup(key);
_queue.Add(previous.HasValue
? new Change <TObject, TKey>(ChangeReason.Update, key, item, previous)
: new Change <TObject, TKey>(ChangeReason.Add, key, item));
_cache.AddOrUpdate(item, key);
}
public void AddOrUpdate(IEnumerable <TObject> items)
{
if (items == null)
{
throw new ArgumentNullException(nameof(items));
}
if (_keySelector == null)
{
throw new KeySelectorException("A key selector must be specified");
}
if (items is IList <TObject> list)
{
//zero allocation enumerator
var enumerable = EnumerableIList.Create(list);
foreach (var item in enumerable)
{
_cache.AddOrUpdate(item, _keySelector(item));
}
}
else
{
foreach (var item in items)
{
_cache.AddOrUpdate(item, _keySelector(item));
}
}
}
public static void GetValue_GetExistingWithRegion_ReturnsValue(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "TestValue", "region1");
cache.AddOrUpdate(1, "TestValue2", "region2");
var value = cache.GetValue(1, "region1");
var value2 = cache.GetValue(1, "region2");
Assert.Equal("TestValue", value);
Assert.Equal("TestValue2", value2);
}
public static void Remove_TryGetValue_ReturnFalse(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "TestValue1");
cache.AddOrUpdate(2, "TestValue2");
cache.Remove(1);
var keyExists1 = cache.TryGet(1, out _);
var keyExists2 = cache.TryGet(2, out _);
Assert.False(keyExists1);
Assert.True(keyExists2);
}
public static void Clear_TryGetValueWithRegions_ReturnFalse(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "TestValue1", "region1");
cache.AddOrUpdate(2, "TestValue2", "region2");
cache.Clear("region1");
var keyExists1 = cache.TryGet(1, out _, "region1");
var keyExists2 = cache.TryGet(2, out _, "region2");
Assert.False(keyExists1);
Assert.True(keyExists2);
Assert.Equal("TestValue2", cache.GetValue(2, "region2"));
}
public static void TryGet_KeyExistsWithRegion_ReturnsTrueAndValue(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "TestValue", "region1");
cache.AddOrUpdate(1, "TestValue2", "region2");
var keyExists = cache.TryGet(1, out var value, "region1");
Assert.True(keyExists);
Assert.Equal("TestValue", value);
var keyExists2 = cache.TryGet(1, out var value2, "region2");
Assert.True(keyExists2);
Assert.Equal("TestValue2", value2);
}
public async Task <IEnumerable <TServiceModel> > GetAll()
{
var items = cache.Get <IEnumerable <TServiceModel> >("all");
if (items != null)
{
return(items);
}
items = await safeService.GetAll();
cache.AddOrUpdate("all", items);
return(items);
}
public static void TryGet_KeyNotExistsWithRegion_ReturnFalse(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "Test", "region1");
Assert.False(cache.TryGet(1, out _));
Assert.False(cache.TryGet(1, out _, "region2"));
}
public static T RetreiveFromCache <T>(this ICache cache, object cacheLock, string cacheKey, DateTime cacheExpiry, Func <T> notInCacheMethod) where T : class
{
//See if the data is already cached
var data = cache.Get <T>(cacheKey);
if (data != null)
{
return(data);
}
lock (cacheLock)
{
//double check in case cache was locked by idetical call
data = cache.Get <T>(cacheKey);
if (data != null)
{
return(data);
}
data = notInCacheMethod();
cache.AddOrUpdate(cacheKey, data, cacheExpiry);
return(data);
}
}
////////////////////////////////////////////////////////////
// IImprovedAssetCache
//
public void Cache(string assetID, AssetBase asset)
{
if (asset != null)
{
m_Cache.AddOrUpdate(asset.IDString, asset);
}
}
internal static T GetOrAddImpl <T>(ICache cache, string key, Func <string, T> constructor,
object cachePolicy = null)
{
lock (cache.LockKey)
{
CacheItem <T> existingItem = cache.GetCacheItem <T>(key);
if (existingItem != null)
{
return(existingItem.Value);
}
}
// Note: it's possible that another thread will have already added an item into the cache with our key
// if this has happened we're going to discard what constructor returns and return what's in the cache
// - this mirrors the behaviour of ConcurrentDictionary
// IMPORTANT: what we do NOT want to do is extend the lock above to include the call to constructor as we
// have no way of knowing how long we would have to wait blocking access to the cache
// If this is a problem for your use case, then use IMultiThreadProtectedCache which will guarantee that
// constructor function will only run once
T newValue = constructor(key);
lock (cache.LockKey)
{
CacheItem <T> existingItem = cache.GetCacheItem <T>(key);
if (existingItem != null)
{
return(existingItem.Value);
}
cache.AddOrUpdate(key, newValue, cachePolicy);
return(newValue);
}
}
////////////////////////////////////////////////////////////
// IImprovedAssetCache
//
public void Cache(AssetBase asset)
{
if (asset != null)
{
m_Cache.AddOrUpdate(asset.ID, asset);
}
}
private async Task <bool> UpdateCacheAndAttemptRetrieval(ICache <int, string> cache, int key, int pauseInMilliseconds)
{
await Task.Delay(TimeSpan.FromMilliseconds(pauseInMilliseconds));
var expectedValue = key.ToString();
Console.WriteLine($"Updating {key}...");
cache.AddOrUpdate(key, expectedValue);
await Task.Delay(TimeSpan.FromSeconds(2));
Console.WriteLine($"Retrieving key {key}...");
var result = cache.TryGetValue(key, out var actualValue);
if (result)
{
Console.WriteLine($"Cache hit on {key}.");
Assert.That(actualValue, Is.EqualTo(expectedValue));
}
else
{
Console.WriteLine($"Cache missed on {key}.");
}
return(result);
}
public static void GetValue_GetExisting_ReturnsValue(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "TestValue");
var value = cache.GetValue(1);
Assert.Equal("TestValue", value);
}
public static async Task TryGetAsync_KeyNotExistsWithRegion_ReturnFalse(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "Test", "region1");
var cacheRequestResult = await cache.TryGetAsync(1).ConfigureAwait(false);
Assert.False(cacheRequestResult.EntryExists);
}
public static async Task GetValueAsync_KeyNotExistsWithRegions_ReturnNull(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "TestValue", "region1");
var value = await cache.GetValueAsync(1, false).ConfigureAwait(false);
Assert.Null(value);
}
public static void GetValue_KeyNotExistsWithRegions_ReturnNull(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "TestValue", "region1");
var value = cache.GetValue(1, false);
Assert.Null(value);
}
public static void Remove_WithRegionsTryGetValue_ReturnFalse(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "TestValue1", "region1");
cache.AddOrUpdate(1, "TestValue1", "region2");
cache.AddOrUpdate(2, "TestValue2", "region1");
cache.AddOrUpdate(2, "TestValue2", "region2");
cache.Remove(1, "region1");
var keyExists1 = cache.TryGet(1, out _, "region1");
var keyExists2 = cache.TryGet(1, out _, "region2");
var keyExists3 = cache.TryGet(2, out _, "region1");
var keyExists4 = cache.TryGet(2, out _, "region2");
Assert.False(keyExists1);
Assert.True(keyExists2);
Assert.True(keyExists3);
Assert.True(keyExists4);
}
public static void TryGet_KeyExists_ReturnsTrueAndValue(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "TestValue");
var keyExists = cache.TryGet(1, out var value);
Assert.True(keyExists);
Assert.Equal("TestValue", value);
}
public IReadOnlyList <ChannelInfo> GetChannels()
{
var value = _cache.Get <IReadOnlyList <ChannelInfo> >(ResourceCacheType.Channels);
if (value == null)
{
Logger.Debug("Caching...");
value = _loader.LoadChannels().ToList();
_cache.AddOrUpdate(ResourceCacheType.Channels, value);
}
return(value);
}
public async Task <IActionResult> GetTokenWithSmallApp(string code)
{
var keyInfo = await _smallAppClient.GetKeyInfo(code);
if (keyInfo.open_id == null)
{
return(BadRequest("获取token失败"));
}
var token = _customTokenProvider.GetToken();
_cache.AddOrUpdate("token", token.access_token);
return(Ok(token));
}
public static async Task TryGet_AfterExpirationTimeSpan_ReturnsFalse(ICache <int, string> cache)
{
var expirationPolicy = A.Fake <ICacheExpirationPolicy>();
A.CallTo(() => expirationPolicy.ExpirationMode).Returns(CacheExpirationMode.SlidingTimeSpan);
A.CallTo(() => expirationPolicy.SlidingTimeSpan).Returns(TimeSpan.FromMilliseconds(50));
cache.AddOrUpdate(1, "TestValue", expirationPolicy);
await Task.Delay(100).ConfigureAwait(false);
Assert.False(cache.TryGet(1, out _));
}
public static void GetValue_KeyNotExistsWithRegions_ThrowsException(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "TestValue", "region1");
var exception = Assert.Throws <CacheEntryNotFoundException>(() => cache.GetValue(1));
Assert.Equal("1", exception.Key);
Assert.Equal(string.Empty, exception.RegionName);
var exception2 = Assert.Throws <CacheEntryNotFoundException>(() => cache.GetValue(1, "region2"));
Assert.Equal("1", exception2.Key);
Assert.Equal("region2", exception2.RegionName);
}
/// <summary>
/// Cache test
/// </summary>
/// <param name="cache">cache instance</param>
private static void Test(ICache <string, TestData> cache)
{
Console.WriteLine("Cache type: {0}.{1}", cache.GetType().Namespace, cache.GetType().Name);
Console.WriteLine("Threads: {0}, Items per thread: {1}, Reads per thread: {2}", threadCount, itemsPerThread, itemsPerThread * readOperationPerWrite);
Stopwatch stopwatch = new Stopwatch();
ManualResetEvent mre = new ManualResetEvent(false);
List <WaitHandle> threadHandles = new List <WaitHandle>();
List <long> memoryUsageList = new List <long>();
for (int i = 0; i < threadCount; i++)
{
EventWaitHandle handle = new EventWaitHandle(false, EventResetMode.ManualReset);
Thread thread = new Thread(new ThreadStart(() =>
{
mre.WaitOne();
Random random = new Random(DateTime.Now.Millisecond);
for (int j = 0; j < itemsPerThread; j++)
{
string key = CreateKey(keyLength);
TestData data = CreateTestData(random);
cache.AddOrUpdate(key, data);
for (int k = 0; k < readOperationPerWrite; k++)
{
string keyToSearch = CreateKey(keyLength);
cache.TryGetValue(keyToSearch, out TestData cachedData);
}
}
handle.Set();
}));
thread.Start();
threadHandles.Add(handle);
}
Timer memoryMonitor = new Timer(new TimerCallback(s => memoryUsageList.Add(Process.GetCurrentProcess().WorkingSet64)), null, 100, 100);
stopwatch.Start();
mre.Set();
WaitHandle.WaitAll(threadHandles.ToArray());
stopwatch.Stop();
memoryMonitor.Dispose();
Console.WriteLine("Time Elapsed: {0}", stopwatch.Elapsed);
Console.WriteLine("Total reads: {0}, total writes: {1}", itemsPerThread * readOperationPerWrite * threadCount, itemsPerThread * threadCount);
Console.WriteLine("Reads per second: {0}, writes per second: {1}", (long)((itemsPerThread * readOperationPerWrite * threadCount) / stopwatch.Elapsed.TotalSeconds), (long)((itemsPerThread * threadCount) / stopwatch.Elapsed.TotalSeconds));
Console.WriteLine("Max memory used (MB): {0}", (long)(memoryUsageList.Max() / 1048576));
Console.WriteLine("Average memory used (MB): {0}", (long)(memoryUsageList.Average() / 1048576));
GC.Collect();
}
public static async Task TryGet_AfterExpiration_ReturnsFalse(ICache <int, string> cache)
{
var expirationPolicy = A.Fake <ICacheExpirationPolicy>();
A.CallTo(() => expirationPolicy.ExpirationMode).Returns(CacheExpirationMode.AbsoluteDateTime);
var expirationDateTime = DateTime.Now;
A.CallTo(() => expirationPolicy.AbsoluteDateTime).Returns(expirationDateTime);
cache.AddOrUpdate(1, "TestValue", expirationPolicy);
await Task.Delay(100).ConfigureAwait(false);
Assert.False(cache.TryGet(1, out _));
}
public static async Task GetValueAsync_KeyNotExistsWithRegions_ThrowsException(ICache <int, string> cache)
{
cache.AddOrUpdate(1, "TestValue", "region1");
var exception =
await Assert.ThrowsAsync <CacheEntryNotFoundException>(async() => await cache.GetValueAsync(1).ConfigureAwait(false));
Assert.Equal("1", exception.Key);
Assert.Equal(string.Empty, exception.RegionName);
var exception2 =
await Assert.ThrowsAsync <CacheEntryNotFoundException>(async() => await cache.GetValueAsync(1, "region2").ConfigureAwait(false));
Assert.Equal("1", exception2.Key);
Assert.Equal("region2", exception2.RegionName);
}
