public void Setup() { _container = new MocksAndStubsContainer(); _applicationSettings = _container.ApplicationSettings; _context = _container.UserContext; _settingsRepository = _container.SettingsRepository; _userRepository = _container.UserRepository; _pageRepository = _container.PageRepository; _settingsService = _container.SettingsService; _userService = _container.UserService; _pageCache = _container.PageViewModelCache; _listCache = _container.ListCache; _siteCache = _container.SiteCache; _cache = _container.MemoryCache; _container.ClearCache(); _pageService = _container.PageService; _wikiImporter = new WikiImporterMock(); _pluginFactory = _container.PluginFactory; _searchService = _container.SearchService; // There's no point mocking WikiExporter (and turning it into an interface) as // a lot of usefulness of these tests would be lost when creating fake Streams and zip files. _wikiExporter = new WikiExporter(_applicationSettings, _pageService, _settingsRepository, _pageRepository, _userRepository, _pluginFactory); _wikiExporter.ExportFolder = AppDomain.CurrentDomain.BaseDirectory; _toolsController = new ToolsController(_applicationSettings, _userService, _settingsService, _pageService, _searchService, _context, _listCache, _pageCache, _wikiImporter, _pluginFactory, _wikiExporter); }
public DocumentCacher(InMemoryRavenConfiguration configuration) { this.configuration = configuration; cachedSerializedDocuments = CreateCache(); MemoryStatistics.RegisterLowMemoryHandler(this); }
/// <summary> /// The constructor. /// </summary> /// <param name="physicalMemoryLimitPercentage">The cache memory limit, as a percentage of the total system memory.</param> /// <param name="performanceDataManager">The performance data manager.</param> internal MemCache(int physicalMemoryLimitPercentage, PerformanceDataManager performanceDataManager) { // Sanitize if (physicalMemoryLimitPercentage <= 0) { throw new ArgumentException("cannot be <= 0", "physicalMemoryLimitPercentage"); } if (performanceDataManager == null) { throw new ArgumentNullException("performanceDataManager"); } var cacheMemoryLimitMegabytes = (int)(((double)physicalMemoryLimitPercentage / 100) * (new ComputerInfo().TotalPhysicalMemory / 1048576)); // bytes / (1024 * 1024) for MB; _cacheName = "Dache"; _cacheConfig = new NameValueCollection(); _cacheConfig.Add("pollingInterval", "00:00:05"); _cacheConfig.Add("cacheMemoryLimitMegabytes", cacheMemoryLimitMegabytes.ToString()); _cacheConfig.Add("physicalMemoryLimitPercentage", physicalMemoryLimitPercentage.ToString()); _memoryCache = new TrimmingMemoryCache(_cacheName, _cacheConfig); _internDictionary = new Dictionary<string, string>(100); _internReferenceDictionary = new Dictionary<string, int>(100); _performanceDataManager = performanceDataManager; // Configure per second timer to fire every 1000 ms starting 1000ms from now _perSecondTimer = new Timer(PerSecondOperations, null, 1000, 1000); }
private GameBot() { _userRequests = new MemoryCache(nameof(_userRequests)); _refreshGamesTimer = new Timer(2000); _refreshGamesTimer.Start(); _refreshGamesTimer.Elapsed += RefreshGamesTimerOnElapsed; }
/// <summary> /// GetFlight with MemoryCache (5 sek) /// </summary> private static List <Flight> GetFlight1(string departure) { string cacheItemName = "FlightSet_" + departure; // Zugriff auf Cache-Eintrag System.Runtime.Caching.MemoryCache cache = System.Runtime.Caching.MemoryCache.Default; List <Flight> flightSet = cache[cacheItemName] as List <Flight>; if (flightSet == null) // Element ist NICHT im Cache { CUI.Print($"{DateTime.Now.ToLongTimeString()}: Cache missed", ConsoleColor.Red); using (var ctx = new WWWingsContext()) { ctx.Log(); // Load flights flightSet = ctx.FlightSet.Where(x => x.Departure == departure).ToList(); } // Store flights in cache CacheItemPolicy policy = new CacheItemPolicy(); policy.AbsoluteExpiration = DateTime.Now.AddSeconds(5); //or: policy.SlidingExpiration = new TimeSpan(0,0,0,5); cache.Set(cacheItemName, flightSet, policy); } else // Data is already in cache { CUI.Print($"{DateTime.Now.ToLongTimeString()}: Cache hit", ConsoleColor.Green); } return(flightSet); }
public void AddOrGetExisting() { var cache2 = new CacheTest(); var cache3 = new CacheTest(); var cache4 = new CacheTest(); System.Runtime.Caching.MemoryCache cache = System.Runtime.Caching.MemoryCache.Default; int cache1_1 = cache.AddOrGetExisting("cache1", 1); int cache1_2 = cache.AddOrGetExisting("cache1", 2); int cache2_1 = cache.AddOrGetExisting("cache2", i => cache2.Increment()); int cache2_2 = cache.AddOrGetExisting("cache2", i => cache2.Increment()); int cache3_1 = cache.AddOrGetExisting("cache3", i => cache3.Increment(), new CacheItemPolicy()); int cache3_2 = cache.AddOrGetExisting("cache3", i => cache3.Increment(), new CacheItemPolicy()); int cache4_1 = cache.AddOrGetExisting("cache4", i => cache4.Increment(), new DateTimeOffset(new DateTime(2100, 01, 01))); int cache4_2 = cache.AddOrGetExisting("cache4", i => cache4.Increment(), new DateTimeOffset(new DateTime(2100, 01, 01))); Assert.AreEqual(1, cache1_1); Assert.AreEqual(1, cache1_2); Assert.AreEqual(1, cache2_1); Assert.AreEqual(1, cache2_2); Assert.AreEqual(1, cache3_1); Assert.AreEqual(1, cache3_2); Assert.AreEqual(1, cache4_1); Assert.AreEqual(1, cache4_2); }
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]); }
public EmailOutputChannel(OutputSetting setting, IStatsTemplate template) : base(setting) { this.template = template; emailSetting = (EmailOutputSetting)setting; cache = MemoryCache.Default; }
public ExpiringCache(ILogger log, Func<string, ICurrentWorkingDirectory, IRepositoryStatus> factory) { _log = log; _factory = factory; _cache = GetCache(); }
public override void Initialise() { if (_cache == null) { _cache = sys.MemoryCache.Default; } }
public void ExistingObject_IncrementByOneAndSetExpirationDate() { // Arrange var key = new SimpleThrottleKey("test", "key"); var limiter = new Limiter() .Limit(1) .Over(100); var cache = new MemoryCache("testing_cache"); var repository = new MemoryThrottleRepository(cache); string id = repository.CreateThrottleKey(key, limiter); var cacheItem = new MemoryThrottleRepository.ThrottleCacheItem() { Count = 1, Expiration = new DateTime(2030, 1, 1) }; cache .Set(id, cacheItem, cacheItem.Expiration); // Act repository.AddOrIncrementWithExpiration(key, limiter); // Assert var item = (MemoryThrottleRepository.ThrottleCacheItem)cache.Get(id); Assert.Equal(2L, item.Count); Assert.Equal(new DateTime(2030, 1, 1), item.Expiration); }
internal MemCache(CacheCommon cacheCommon) : base(cacheCommon) { // config initialization is done by Init. Assembly asm = Assembly.Load("System.Runtime.Caching, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL"); Type t = asm.GetType("System.Runtime.Caching.MemoryCache", true, false); _cacheInternal = HttpRuntime.CreateNonPublicInstance(t, new object[] {"asp_icache", null, true}) as MemoryCache; _cachePublic = HttpRuntime.CreateNonPublicInstance(t, new object[] {"asp_pcache", null, true}) as MemoryCache; }
public CacheTestSetupHelper() { _cacheReference = new MemoryCache("unit-tester"); var metadata = new ProviderMetadata("cache", new Uri("cache://"), false, true); var frameworkContext = new FakeFrameworkContext(); var schemaRepositoryFactory = new SchemaRepositoryFactory( metadata, new NullProviderRevisionRepositoryFactory<EntitySchema>(metadata, frameworkContext), frameworkContext, new DependencyHelper(metadata, new CacheHelper(CacheReference))); var revisionRepositoryFactory = new EntityRevisionRepositoryFactory( metadata, frameworkContext, new DependencyHelper(metadata, new CacheHelper(CacheReference))); var entityRepositoryFactory = new EntityRepositoryFactory( metadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, new DependencyHelper(metadata, new CacheHelper(CacheReference))); var unitFactory = new ProviderUnitFactory(entityRepositoryFactory); var readonlyUnitFactory = new ReadonlyProviderUnitFactory(entityRepositoryFactory); ProviderSetup = new ProviderSetup(unitFactory, metadata, frameworkContext, new NoopProviderBootstrapper(), 0); ReadonlyProviderSetup = new ReadonlyProviderSetup(readonlyUnitFactory, metadata, frameworkContext, new NoopProviderBootstrapper(), 0); }
public override void Initialise() { if (_cache == null) { _cache = new sys.MemoryCache(Assembly.GetExecutingAssembly().FullName); } }
public MemoryAdapter(CacheSettings cacheSettings) { CacheSettings = cacheSettings; _memoryCache = new MemoryCache(cacheSettings.Name); _expirationType = cacheSettings.ExpirationType; _minutesToExpire = cacheSettings.TimeToLive; }
private RuntimeCacheProvider() { if (HttpContext.Current == null) { _memoryCache = new MemoryCache("in-memory"); } }
//private static DataCacheFactory _factory; static MatchingService() { //DataCacheFactory factory = new DataCacheFactory(); //_cache = factory.GetCache("default"); _cache = MemoryCache.Default; //Debug.Assert(_cache == null); }
void IMemoryCacheManager.ReleaseCache(MemoryCache memoryCache) { if (memoryCache == null) { throw new ArgumentNullException("memoryCache"); } long sizeUpdate = 0L; lock (this._lock) { if (this._cacheInfos != null) { MemoryCacheInfo info = null; if (this._cacheInfos.TryGetValue(memoryCache, out info)) { sizeUpdate = -info.Size; this._cacheInfos.Remove(memoryCache); } } } if (sizeUpdate != 0L) { ApplicationManager applicationManager = HostingEnvironment.GetApplicationManager(); if (applicationManager != null) { applicationManager.GetUpdatedTotalCacheSize(sizeUpdate); } } }
public void RetrieveValidThrottleCountFromRepostitory() { // Arrange var key = new SimpleThrottleKey("test", "key"); var limiter = new Limiter() .Limit(1) .Over(100); var cache = new MemoryCache("testing_cache"); var repository = new MemoryThrottleRepository(cache); string id = repository.CreateThrottleKey(key, limiter); var cacheItem = new MemoryThrottleRepository.ThrottleCacheItem() { Count = 1, Expiration = new DateTime(2030, 1, 1) }; repository.AddOrIncrementWithExpiration(key, limiter); // Act var count = repository.GetThrottleCount(key, limiter); // Assert Assert.Equal(count, 1); }
public Instance(Configuration configuration, string domain, Index index = null) { // Set instance on configuration Configuration = configuration; // Init things ObjDb = new Db(Configuration.Object.Database.ConnectionString); // Database CacheObj = new MemoryCache("instance-obj-" + domain); // Cache //CacheQ = new MemoryCache("instance-q-" + domain); // Cache if (null == index) { // Create new index Index = new Index(Configuration.Schema); // Build base index var retry = new RetryPolicy<DbRetryStrategy>(3, new TimeSpan(0, 0, 1)); using (var rdr = ObjDb.Query("SELECT [uid],[type],[serial],[properties] FROM [obj] WHERE [oid] NOT IN (SELECT [predecessor] FROM [obj])").ExecuteReaderWithRetry(retry)) { while (rdr.Read()) { Index.Set((string)rdr["uid"], (string)rdr["type"], (long)rdr["serial"], (string)rdr["properties"]); } } } else { Index = index; } // Init mode Mode = Amos.ImplementationMode.Mode.Select(Configuration.Mode, this); }
internal CacheMemoryMonitor(MemoryCache memoryCache, int cacheMemoryLimitMegabytes) { _memoryCache = memoryCache; _gen2Count = GC.CollectionCount(2); _cacheSizeSamples = new long[SAMPLE_COUNT]; _cacheSizeSampleTimes = new DateTime[SAMPLE_COUNT]; InitMemoryCacheManager(); InitDisposableMembers(cacheMemoryLimitMegabytes); }
private void GenerateAndBindNrlCache() { MemoryCache memoryCache = new MemoryCache("NrlCache"); Kernel.Bind<INrlCache>() .To<NrlCache>() .InSingletonScope() .WithConstructorArgument("memoryCache", memoryCache); }
public GameBroadcastListener(int port = 21234) { Port = port; IsListening = false; // Expected: System.InvalidOperationException // Additional information: The requested Performance Counter is not a custom counter, it has to be initialized as ReadOnly. GameCache = new MemoryCache("gamebroadcastlistenercache"); }
static ObjectServiceExceptionStore() { timeoutSeconds = 3600; cacheName = "ObjectSerficeExceptionStore"; cache = CacheManager.GetCache(cacheName); policy = new CacheItemPolicy(); policy.AbsoluteExpiration = DateTime.Now + TimeSpan.FromSeconds(timeoutSeconds); }
protected override void TestSetup() { memoryCacheReference = MemoryCache.Default; CacheBuilder.For<ObjectWithMultipleParameters>() .CacheMethod(x => x.Calculate(0, null, 0)) .AsImplemented(); component = CacheBuilder.BuildFactory().Create<ObjectWithMultipleParameters>(); }
static SimpleDataRepository() { const string DIRECTORY = "C:\\x\\cacheit"; var objectCache = new MemoryCache("{7D8DAD94-A0EF-4168-ACB5-2574DC000F26}"); Directory directory = new CacheDirectory(objectCache, DIRECTORY); simpleDataIndex = new SimpleDataIndex(Items, directory); }
public MemoryCacheProvider(string name) { Name = name; m_memoryCache = new MemoryCache(Name); m_policy = new CacheItemPolicy(); m_policy.SlidingExpiration = TimeSpan.FromHours(1); }
public LookUp(ArrayList fingerList, int gender, byte[] probeTemplate, MemoryCache cache, CancellationToken ct) { _fingerList = fingerList; _gender = gender; _probeTemplate = probeTemplate; _cache = cache; _ct = ct; }
public MemoryCache(System.Runtime.Caching.MemoryCache cache) { this.cache = cache; DefaultCacheCapabilities = cache.DefaultCacheCapabilities; Name = cache.Name; }
protected override void InitialiseInternal() { if (_cache == null) { Log.Debug("MemoryCache.Initialise - initialising with cacheName: {0}", CacheConfiguration.Current.DefaultCacheName); _cache = new sys.MemoryCache(CacheConfiguration.Current.DefaultCacheName); } }
public void ClearCache() { lock (_locker) { _cacheInfraestructure.Dispose(); _cacheInfraestructure = new MemoryCache(CacheName); } }
/// <summary> /// Initializes a new instance of the <see cref="RedisCache"/> class. /// </summary> /// <param name="name">The name.</param> /// <param name="hostname">The hostname.</param> public RedisCache(string name, string hostname = "localhost") : base(name) { _redis = ConnectionMultiplexer.Connect(hostname); _redis.PreserveAsyncOrder = false; _redisDb = _redis.GetDatabase(); _level1Cache = new MemoryCache(name); }
protected override void InitialiseInternal() { if (_cache == null) { //Log.Debug("MemoryCache.Initialise - initialising with cacheName: {0}", CacheConfiguration.Current.DefaultCacheName); _cache = new sys.MemoryCache(CacheConfiguration.Current.DefaultCacheName); } }
public void HandleLowMemory() { var oldCache = cachedSerializedDocuments; cachedSerializedDocuments = CreateCache(); oldCache.Dispose(); }
public override void Initialise() { if (_cache == null) { //Log.Debug("MemoryCache.Initialise - initialising with cacheName: {0}", CacheConfiguration.Current.DefaultCacheName); // _cache = new sys.MemoryCache(CacheConfiguration.Current.DefaultCacheName); _cache = sys.MemoryCache.Default; } }
public void ClearCache() { var newCache = new MemCache("CacheService"); var oldCache = _cache; _cache = newCache; oldCache.Dispose(); }
private static System.Runtime.Caching.MemoryCache GetInstance() { if (_cache == null) { _cache = new System.Runtime.Caching.MemoryCache("privateCache"); } return(_cache); }
public static object Value(string key) { string NewKey = TransformKey(key); System.Runtime.Caching.MemoryCache cache = System.Runtime.Caching.MemoryCache.Default; if (cache.Contains(NewKey)) { return(cache[NewKey]); } return(string.Empty); }
/// <summary> /// Clears the cache. /// </summary> public void Flush() { lock (_lockObj) { if (_cache != null) { _cache.Dispose(); _ttls.Clear(); } _cache = new System.Runtime.Caching.MemoryCache("stackredis.l1.objmemcache"); } }
public MemoryCache(string region, IDictionary <string, string> properties) { this.region = string.IsNullOrEmpty(region) ? Guid.NewGuid().ToString() : region; cache = new System.Runtime.Caching.MemoryCache(this.region); Configure(properties); rootCacheKey = GenerateRootCacheKey(); StoreRootCacheKey(); }
public MemoryCache(int expiry) { #if NET451 _cache = System.Runtime.Caching.MemoryCache.Default; _policyFactory = () => new CacheItemPolicy(); #else _cacheOptions = new MemoryCacheEntryOptions { SlidingExpiration = TimeSpan.FromMinutes(expiry) }; _cache = new Microsoft.Extensions.Caching.Memory.MemoryCache(new MemoryCacheOptions()); #endif }
public MemoryCache(string regionName, IDictionary <string, string> properties) { this.regionName = regionName; this.policy = new CacheItemPolicy() { SlidingExpiration = GetExpiration(properties), Priority = GetPriority(properties) }; this.cache = System.Runtime.Caching.MemoryCache.Default; this.rootCacheKey = GenerateRootCacheKey(); this.policy.ChangeMonitors.Add( this.cache.CreateCacheEntryChangeMonitor(new[] { rootCacheKey }, regionName) ); }
// getPersonTkn() - Get a person's token. public static token getPersonTkn() { // Extract my tokenID string myTokenID = HttpContext.Current.Request.Headers["majama60"]; // Get token object from cache System.Runtime.Caching.MemoryCache memCache = System.Runtime.Caching.MemoryCache.Default; var res = memCache.Get(myTokenID); if (res == null) { return(null); } else { token myToken = (token)res; return(myToken); } }
public static IEnumerable <DTO.LocationDTO> GetLocations() { HttpClient client = ApiLocationClient(); var cache = new System.Runtime.Caching.MemoryCache("locations"); var cacheItemPolicy = new CacheItemPolicy() { //Set your Cache expiration. AbsoluteExpiration = DateTime.Now.AddDays(1) }; IEnumerable <DTO.LocationDTO> result; if (cache["locations"] == null) { result = GetLocationsFromervice(client);; cache["locations"] = result; } else { result = (IEnumerable <DTO.LocationDTO>)cache["locations"]; } return(result); }
public CacheRepository(IRepository repository, IEventStore eventStore) { if (repository == null) { throw new ArgumentNullException("repository"); } if (eventStore == null) { throw new ArgumentNullException("eventStore"); } _repository = repository; _eventStore = eventStore; _cache = System.Runtime.Caching.MemoryCache.Default; _policyFactory = () => new CacheItemPolicy { SlidingExpiration = new TimeSpan(0, 0, 15, 0), RemovedCallback = x => { object o; _locks.TryRemove(x.CacheItem.Key, out o); } }; }
/// <summary> /// 初始化一个<see cref="MemoryCache" />实例。 /// </summary> /// <param name="region"></param> public MemoryCache(string region) { _cache = new System.Runtime.Caching.MemoryCache(region); _region = region; }
public MemoryCacheManagement() { _cache = MemoryCache.Default; }
/// <summary> /// Инициализирует новый экземпляр класса <see cref="MemoryCacheProvider"/>. /// </summary> /// <param name="cache"> /// The cache. /// </param> public MemoryCacheProvider(System.Runtime.Caching.MemoryCache cache) { this._cache = cache; }
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)); }
public static bool Exists(string key) { System.Runtime.Caching.MemoryCache cache = System.Runtime.Caching.MemoryCache.Default; return(cache.Contains(TransformKey(key))); }
public MemoryCache(System.Runtime.Caching.MemoryCache memoryCache) { _regionCache = new RegionCache(memoryCache); }
public MemoryCache(string name) : base() { _memoryCache = new System.Runtime.Caching.MemoryCache(name); }
public override void ClearAll() { _cache.Dispose(); _cache = System.Runtime.Caching.MemoryCache.Default; }
public MemoryCacheProvider(string name = "Default", NameValueCollection config = null) { Cache = new System.Runtime.Caching.MemoryCache(name, config); }
public MemoryCache(string cacheName) { _cache = new System.Runtime.Caching.MemoryCache(cacheName); }
/// <summary> /// Initializes a new instance of the <see cref="MemoryCache"/> class. /// </summary> public MemoryCache() { this.cache = System.Runtime.Caching.MemoryCache.Default; }
public MemoryCacheProvider() { _cache = System.Runtime.Caching.MemoryCache.Default; }
MemoryCache() { _cache = System.Runtime.Caching.MemoryCache.Default; _defaultSettings = new Settings(); }