public void IsFull_When_NotFull_Expect_False() { var cache = new Cache <int, int>(capacity: 5); cache.AddOrUpdate(0, 10); cache.AddOrUpdate(1, 20); cache.AddOrUpdate(2, 30); cache.AddOrUpdate(3, 40); Assert.False(cache.IsFull); }
public void Can_Update_Existing_Values() { var cache = new Cache <string, int>(10); cache.AddOrUpdate("one", 1); cache.AddOrUpdate("one", 2); var result = cache.TryGetValue("one", out var value); Assert.That(result, Is.True); Assert.That(value, Is.EqualTo(2)); }
private static Cache <int, string> _Cache2 = new Cache <int, string>(); //GC (1) public static void Run() { _Cache1.TryAdd(1, "value1", DateTimeOffset.Now.AddMinutes(1)); _Cache1.TryAdd(2, () => "value2", DateTimeOffset.Now.AddMinutes(2)); _Cache1.TryAdd(3, () => ("value3", DateTimeOffset.Now.AddDays(3))); _Cache1.TryAdd(101, "value101", TimeSpan.FromMinutes(1)); _Cache1.TryAdd(102, "value102", TimeSpan.FromMinutes(2)); _Cache1.TryAdd(103, "value103", TimeSpan.FromMinutes(3)); _Cache1.TryUpdate(1, "newValue1", out var oldValue1); _Cache1.TryUpdate(2, value1 => "newValue2", out var oldValue2); _Cache1.TryUpdate(3, DateTimeOffset.Now.AddDays(1), out var value3); _Cache1.TryUpdate(4, "newValue4", DateTimeOffset.Now.AddDays(2), out var oldValue4); _Cache1.TryUpdate(5, (value5) => "newValue5", DateTimeOffset.Now.AddDays(3), out var oldValue5); _Cache1.TryUpdate(6, (value5, expire5) => ("newValue6", DateTimeOffset.Now.AddDays(4)), out var oldValue6); _Cache1.AddOrUpdate(1, "value1", DateTimeOffset.Now.AddYears(1)); _Cache1.AddOrUpdate(2, "newValue2", DateTimeOffset.Now.AddYears(2), (value2) => "updateValue2"); _Cache1.AddOrUpdate(3, () => ("newValue2", DateTimeOffset.Now.AddYears(3)), (value3, expire3) => ("updateValue3", DateTimeOffset.Now.AddYears(3))); _Cache1.GetOrAdd(4, "Value4", DateTimeOffset.Now.AddSeconds(1)); _Cache1.GetOrAdd(5, () => "Value5", DateTimeOffset.Now.AddSeconds(2)); _Cache1.GetOrAdd(6, () => ("Value6", DateTimeOffset.Now.AddSeconds(3))); _Cache1.TryGetValue(1, out var getValue1); _Cache1.TryGetValue(2, out var getValue2); _Cache1.TryGetValue(3, out var getValue3); _Cache1.TryGetValue(4, out var getValue4); _Cache1.TryGetValue(5, out var getValue5); _Cache1.TryGetValue(6, out var getValue6); Console.WriteLine(getValue1); Console.WriteLine(getValue2); Console.WriteLine(getValue3); Console.WriteLine(getValue4); Console.WriteLine(getValue5); Console.WriteLine(getValue6); _Cache1.ForEach((key, value, expire) => { Console.WriteLine($"{key}={value},{expire}"); }); _Cache1.TryRemove(1, out var oldValue11); _Cache1.Collect(); //_Cache1.Clear(); }
public void Least_Recently_Inserted_Key_Is_Removed_On_AddOrUpdate() { var cache = new Cache <string, string>(2); cache.AddOrUpdate("apple", "first"); cache.AddOrUpdate("banana", "second"); cache.AddOrUpdate("pear", "third"); var result = cache.TryGetValue("apple", out var value); Assert.That(result, Is.False); Assert.That(value, Is.EqualTo(null)); }
//Updating existing node (same key, different value) a few times //Expect value of the node to be the lastest updated one public void AddOrUpdate_When_KeyIdentical_Expect_ValueToBeUpdated() { var cache = new Cache <int, string>(capacity: 5); var key = 0; string MostUpdatedValue = "Last update for initial node"; string valueInCache; cache.AddOrUpdate(0, "Initial node"); cache.AddOrUpdate(0, "Same node updated"); cache.AddOrUpdate(0, MostUpdatedValue); Assert.True(cache.TryGetValue(key, out valueInCache)); Assert.AreEqual(MostUpdatedValue, valueInCache, "Value in cache does not match value put in"); }
public void Cache_Update_Item_Ok() { Cache c = new Cache(); object o1 = new object(); object o2 = new object(); c.AddOrUpdate("test", o1, 1); Assert.Same(c.Get("test"), o1); c.AddOrUpdate("test", o2, 1); Assert.Same(c.Get("test"), o2); Thread.Sleep(1050); Assert.False(c.Exists("test")); }
public static ITokenManager GetTokenManager() { ITokenManager tokenManager; try { tokenManager = Cache.Get <ITokenManager>("tokenManager"); if (null != tokenManager) { return(tokenManager); } var certificateDetails = Cache.Get <ICertificateDetails>("ICertificateDetails"); var thumbPrint = certificateDetails.GetCertificateThumbPrint(); if (String.IsNullOrEmpty(thumbPrint)) { tokenManager = new SymmetricKeyTokenManager(); } else { tokenManager = new CertificateTokenManager(certificateDetails); } } catch (Exception) { tokenManager = new SymmetricKeyTokenManager(); } Cache.AddOrUpdate(tokenManager, "tokenManager", 20000); return(tokenManager); }
public Int32 getKey(string value) { object key; string desc; if (caseSensitive) { desc = value; } else { desc = value.ToLower(); } if (!Cache.TryGet(keyContext, desc, out key)) { aLock.AcquireReaderLock(TIMEOUT); try { findKey.Parameters["@value"].Value = desc; key = findKey.ExecuteScalar(); if (key == null) { key = AddEntry(desc); } Cache.AddOrUpdate(keyContext, desc, key); } finally { aLock.ReleaseReaderLock(); } } return((Int32)key); }
public ReportAccessHub(IUserQueryService userQuerySvc, IReportQueueService reportQueueService) { _userQuerySvc = userQuerySvc; _reportQueueService = reportQueueService; // Get cached user information. // TODO: Determine how to handle cache expiration. _reportUsers = Cache.Get <ConcurrentDictionary <Guid, List <Guid> > >("reportUsers"); if (_reportUsers == null) { _reportUsers = new ConcurrentDictionary <Guid, List <Guid> >(); Cache.AddOrUpdate(_reportUsers, "reportUsers"); } _userConnections = Cache.Get <ConcurrentDictionary <Guid, List <string> > >("reportUserConnections"); if (_userConnections == null) { _userConnections = new ConcurrentDictionary <Guid, List <string> >(); Cache.AddOrUpdate(_userConnections, "reportUserConnections"); } _reportMonitors = Cache.Get <ConcurrentDictionary <string, List <Guid> > >("reportMonitors"); if (_reportMonitors == null) { _reportMonitors = new ConcurrentDictionary <string, List <Guid> >(); Cache.AddOrUpdate(_reportMonitors, "reportMonitors"); } }
public void ObjectUpdate(TimeSpan elapsedTime) { var users = ServerContext.Game.Clients.Where(i => i != null && i.Aisling != null && i.Aisling.CurrentMapId == ID) .Select(i => i.Aisling).ToArray(); Sprite[] ObjectCache = null; if (!AreaObjectCache.Exists(Name)) { ObjectCache = GetAreaObjects(); if (ObjectCache.Length > 0) { AreaObjectCache.AddOrUpdate(Name, ObjectCache, 3); } } else { ObjectCache = AreaObjectCache.Get(Name); } if (ObjectCache != null && ObjectCache.Length > 0) { if (users.Length > 0) { UpdateMonsterObjects(elapsedTime, ObjectCache.OfType <Monster>()); UpdateMundaneObjects(elapsedTime, ObjectCache.OfType <Mundane>()); UpdateItemObjects(elapsedTime, ObjectCache.OfType <Money>().Concat <Sprite>(ObjectCache.OfType <Item>())); } } }
public void Can_Add_And_Retrieve_Values_By_Key() { var cache = new Cache <string, int>(10); cache.AddOrUpdate("one", 1); cache.AddOrUpdate("two", 2); var result = cache.TryGetValue("one", out var value); Assert.That(result, Is.True); Assert.That(value, Is.EqualTo(1)); result = cache.TryGetValue("two", out value); Assert.That(result, Is.True); Assert.That(value, Is.EqualTo(2)); }
protected sealed override TOutputToMap ComputeByIndexImpl(IReadOnlyList <TMappedInput> mappedInputs, int index) { var tick = default(TOutputToMap); if (index < InitialValueIndex) { tick = ComputeNullValue(mappedInputs, index); } else if (index == InitialValueIndex) { tick = ComputeInitialValue(mappedInputs, index); } else { // get start index of calculation to cache int cacheStartIndex = Cache.Keys.DefaultIfEmpty(InitialValueIndex).Where(k => k >= InitialValueIndex).Max(); for (int i = cacheStartIndex; i < index; i++) { var prevTick = Cache.GetOrAdd(i, _i => ComputeByIndexImpl(mappedInputs, _i)); tick = ComputeCumulativeValue(mappedInputs, i + 1, prevTick); // The result will be cached in the base class for the return tick if (i < index - 1) { Cache.AddOrUpdate(i + 1, tick, (_i, _t) => tick); } } } return(tick); }
public void AddOrReplace(K key, V value, Func <UpdateableCacheEntry <V>, bool> invalidation, Func <V, CancellationToken, Task <V> > update) { var cacheEntry = UpdateableCacheEntry.From(value, DateTimeOffset.UtcNow, invalidation, update); Cache.AddOrUpdate(key, cacheEntry, (k, e) => UpdateableCacheEntry.From(e, value, _clock.UtcNow)); }
public void UpdateAreaObjects(TimeSpan elapsedTime) { var users = ServerContextBase.Game.Clients.Where(i => i?.Aisling != null && i.Aisling.CurrentMapId == ID) .Select(i => i.Aisling).ToArray(); Sprite[] objectCache; if (!AreaObjectCache.Exists(Name)) { objectCache = GetAreaObjects(); if (objectCache.Length > 0) { AreaObjectCache.AddOrUpdate(Name, objectCache, 3); } } else { objectCache = AreaObjectCache.Get(Name); } if (objectCache == null || objectCache.Length <= 0) { return; } if (users.Length <= 0) { return; } UpdateMonsterObjects(elapsedTime, objectCache.OfType <Monster>()); UpdateMundaneObjects(elapsedTime, objectCache.OfType <Mundane>()); UpdateItemObjects(elapsedTime, objectCache.OfType <Money>().Concat <Sprite>(objectCache.OfType <Item>())); }
/// <summary> /// Attempts to load a new dataset and replaces the old one if load was successful /// </summary> /// <param name="arguments">The arguments for the update event.</param> protected virtual void UpdateLoadedDataSet(ResourceUpdatedEventArgs arguments) { RunExclusiveAction action = AllowMultipleThreadsLoadingDataSet ? m_action : s_action; action.Do(() => { if (arguments.IsInitialLoad) { ULSLogging.LogTraceTag(0x23821004 /* tag_967ae */, Categories.ConfigurationDataSet, Levels.Verbose, "Adding data set type '{0}' to cache.", typeof(T).Name); if (Cache.GetOrAdd(typeof(IConfigurationDataSetLoader <T>), () => CreateCachedConfigurationDataSet(new CachedConfigurationDataSet <T>(DataSetOverride), arguments), out bool wasAdded) is CachedConfigurationDataSet <T> result && wasAdded) { OnLoad(result.LoadDetails); } } else { ULSLogging.LogTraceTag(0x23850399 /* tag_97qoz */, Categories.ConfigurationDataSet, Levels.Verbose, "Updating data set type '{0}' in cache.", typeof(T).Name); CachedConfigurationDataSet <T> dataSets = DataSets; IList <ConfigurationDataSetLoadDetails> loadDetails = dataSets.LoadDetails; if (Cache.AddOrUpdate(typeof(IConfigurationDataSetLoader <T>), () => CreateCachedConfigurationDataSet(dataSets, arguments), out bool wasUpdated) is CachedConfigurationDataSet <T> result && wasUpdated) { OnReload(loadDetails, result.LoadDetails); } } }); }
public void AddOrUpdate_WithRegionAndValidity() { Cache.AddOrUpdate(_cacheItem, Key, Region, 2000); var cacheDetails = Cache.Get <CacheItem>(Key); cacheDetails.Should().NotBeNull(); }
private void InitializeTokenManager() { ICertificateDetails fedCertificateDetails = new FedCertificateDetails(); Cache.AddOrUpdate(fedCertificateDetails, "ICertificateDetails", 20000); TokenManagerFactory.GetTokenManager(); }
public void AddOrUpdate_WithKey() { Cache.AddOrUpdate(_cacheItem, Key); var cacheDetails = Cache.Get <CacheItem>(Key); cacheDetails.Should().NotBeNull(); }
public void Cache_Restart_Timer_Ok() { Cache c = new Cache(); object o1 = new object(); c.AddOrUpdate("test", o1, 1); Thread.Sleep(800); // wait almost a second Assert.True(c.Exists("test")); // still exists c.AddOrUpdate("test", o1, 1, true); // update and refresh the timer Thread.Sleep(1000); // wait another second Assert.True(c.Exists("test")); // still exists c.AddOrUpdate("test", o1, 1, false); // default parameter 4: false - no refresh of the timer Thread.Sleep(500); // it should expire now Assert.Null(c.Get("test")); // no longer cached }
public void Setup() { _cache = new Cache <int, int>(10); for (int i = 0; i < 9; i++) { _cache.AddOrUpdate(i, i); } }
public override void AddOrReplace(TKey key, TValue value) { var cacheEntry = CacheEntry.From(value, DateTimeOffset.UtcNow); Cache.AddOrUpdate(key, _ => cacheEntry, (_1, _2) => cacheEntry); }
public void Cache_Timeout_Zero_Throws() { Cache c = new Cache(); void act() => c.AddOrUpdate("test", new object(), 0); Assert.Throws <ArgumentOutOfRangeException>(act); }
public void Cache_Indexer_Found_Ok() { Cache c = new Cache(); object o1 = new object(); c.AddOrUpdate("test", o1, 1); Assert.Same(c["test"], o1); }
public void Cache_Remove_By_Pattern_Ok() { Cache c = new Cache(); c.AddOrUpdate("test1", new object()); c.AddOrUpdate("test2", new object()); c.AddOrUpdate("test3", new object()); c.AddOrUpdate("Other", new object()); Assert.True(c.Exists("test1")); Assert.True(c.Exists("Other")); c.Remove(k => k.StartsWith("test")); Assert.False(c.Exists("test1")); Assert.False(c.Exists("test2")); Assert.False(c.Exists("test3")); Assert.True(c.Exists("Other")); }
public void Cache_Clear_Ok() { Cache c = new Cache(); c.AddOrUpdate("test", new object()); Assert.True(c.Exists("test")); c.Clear(); Assert.False(c.Exists("test")); }
public void TokenManagerFactory_GetCertificateTokenManager() { var fedCertificateDetails = new FedCertificateDetails(); Cache.AddOrUpdate(fedCertificateDetails, "ICertificateDetails", 20000); var tokenManager = TokenManagerFactory.GetTokenManager(); Assert.IsNotNull(tokenManager); }
public void ShouldCollectStatistic() { // when Cache.AddOrUpdate("key1", new object()); // then CacheStatistics statistics = Cache.As <IStatisticsCache>().Statistics; Assert.That(statistics.HasStatictic(CacheStatisticsKeys.LastWrite), Is.True); }
protected TOutputToMap ComputeByIndex(IEnumerable <TMappedInput> mappedInputs, int index) { if (Cache.TryGetValue(index, out TOutputToMap value)) { return(value); } value = ComputeByIndexImpl(mappedInputs, index); Cache.AddOrUpdate(index, value); return(value); }
public void Rejects_Null_Key() { var cache = new Cache <string, string>(10); var e = Assert.Throws <ArgumentNullException>(() => cache.AddOrUpdate(null, "value")); Assert.That(e.Message, Is.EqualTo("key cannot be null.\r\nParameter name: key")); e = Assert.Throws <ArgumentNullException>(() => cache.TryGetValue(null, out var value)); Assert.That(e.Message, Is.EqualTo("key cannot be null.\r\nParameter name: key")); }
public void Cache_Can_Store_Null_Value_For_Key() { var cache = new Cache <string, string>(10); cache.AddOrUpdate("one", null); var result = cache.TryGetValue("one", out var value); Assert.That(result, Is.True); Assert.That(value, Is.Null); }