public RedisCacheManager(IRedisConnectionWrapper redisConnectionWrapper, IMemoryCacheManager memoryCacheManager) { _redisConnectionWrapper = redisConnectionWrapper; _memoryCacheManager = memoryCacheManager; this._db = _redisConnectionWrapper.Database(); }
protected override int GetCurrentPressure() { int num = GC.CollectionCount(2); SRef ref2 = this._sizedRef; if ((num != this._gen2Count) && (ref2 != null)) { this._gen2Count = num; this._idx ^= 1; this._cacheSizeSampleTimes[this._idx] = DateTime.UtcNow; this._cacheSizeSamples[this._idx] = ref2.ApproximateSize; IMemoryCacheManager manager = s_memoryCacheManager; if (manager != null) { manager.UpdateCacheSize(this._cacheSizeSamples[this._idx], this._memoryCache); } } if (this._memoryLimit <= 0L) { return(0); } long num2 = this._cacheSizeSamples[this._idx]; if (num2 > this._memoryLimit) { num2 = this._memoryLimit; } return((int)((num2 * 100L) / this._memoryLimit)); }
/// <summary> /// 构造函数 /// </summary> /// <param name="memoryCacheManager">内存缓存</param> /// <param name="redisCacheManager">redis</param> /// <param name="loggerFactory"></param> public DefaultHybridCacheManager(IMemoryCacheManager memoryCacheManager, IRedisCacheManager redisCacheManager, ILoggerFactory loggerFactory) { _providers = new List <IHybridCacheProvider> { memoryCacheManager, redisCacheManager }; _loggerLazy = new Lazy <ILogger>(() => loggerFactory?.CreateLogger <DefaultHybridCacheManager>() ?? NullLogger <DefaultHybridCacheManager> .Instance); }
public BaseService(IBaseCRUDRepository <TEntity> repository, IMemoryCacheManager memoryCacheManager, IMapper mapper, IConfiguration configuration) { _repository = repository; _mapperDependency = mapper; _configuration = configuration; _memoryCacheManager = memoryCacheManager; }
public ContentController(IContentRepository contentRepository, ICategoryRepository categoryRepository, IUserRepository userRepository, IMediaItemRepository mediaItemRepository, IMemoryCacheManager cacheManager) { _contentRepository = contentRepository; _categoryRepository = categoryRepository; _userRepository = userRepository; _mediaItemRepository = mediaItemRepository; _cacheManager = cacheManager; }
public VBRequestPOExternalService(PurchasingDbContext dbContext, IServiceProvider serviceProvider) { _dbContext = dbContext; _identityService = serviceProvider.GetService <IdentityService>(); _cacheManager = serviceProvider.GetService <IMemoryCacheManager>(); _currencyProvider = serviceProvider.GetService <ICurrencyProvider>(); _serviceProvider = serviceProvider; }
public static T Set <T>(this IMemoryCacheManager cache, object key, T value) { var entry = cache.CreateEntry(key); entry.Value = value; entry.Dispose(); return(value); }
public PPHBankExpenditureNoteFacade(PurchasingDbContext dbContext, IBankDocumentNumberGenerator bankDocumentNumberGenerator, IServiceProvider serviceProvider) { this.dbContext = dbContext; this.dbSet = dbContext.Set <PPHBankExpenditureNote>(); this.dbSetPurchasingDocumentExpedition = dbContext.Set <PurchasingDocumentExpedition>(); this.bankDocumentNumberGenerator = bankDocumentNumberGenerator; _serviceProvider = serviceProvider; _cacheManager = (IMemoryCacheManager)serviceProvider.GetService(typeof(IMemoryCacheManager)); }
protected override int GetCurrentPressure() { // Call GetUpdatedTotalCacheSize to update the total // cache size, if there has been a recent Gen 2 Collection. // This update must happen, otherwise the CacheManager won't // know the total cache size. int gen2Count = GC.CollectionCount(2); SRefMultiple sref = _sizedRefMultiple; if (gen2Count != _gen2Count && sref != null) { // update _gen2Count _gen2Count = gen2Count; // the SizedRef is only updated after a Gen2 Collection // increment the index (it's either 1 or 0) Dbg.Assert(SAMPLE_COUNT == 2); _idx = _idx ^ 1; // remember the sample time _cacheSizeSampleTimes[_idx] = DateTime.UtcNow; // remember the sample value _cacheSizeSamples[_idx] = sref.ApproximateSize; #if DBG Dbg.Trace("MemoryCacheStats", "SizedRef.ApproximateSize=" + _cacheSizeSamples[_idx]); #endif IMemoryCacheManager memoryCacheManager = s_memoryCacheManager; if (memoryCacheManager != null) { memoryCacheManager.UpdateCacheSize(_cacheSizeSamples[_idx], _memoryCache); } } // if there's no memory limit, then there's nothing more to do if (_memoryLimit <= 0) { return(0); } long cacheSize = _cacheSizeSamples[_idx]; // use _memoryLimit as an upper bound so that pressure is a percentage (between 0 and 100, inclusive). if (cacheSize > _memoryLimit) { cacheSize = _memoryLimit; } // PerfCounter: Cache Percentage Process Memory Limit Used // = memory used by this process / process memory limit at pressureHigh // Set private bytes used in kilobytes because the counter is a DWORD // int result = (int)(cacheSize * 100 / _memoryLimit); return(result); }
public MenuService(IUnitOfWork unitOfWork , IMemoryCacheManager memoryCacheManager , IEnumReferenceService enumReferenceService , IRepository <sys_Menu> repoMenu) { this._unitOfWork = unitOfWork; this._memoryCacheManager = memoryCacheManager; this._enumReferenceService = enumReferenceService; this._repoMenu = repoMenu; }
public static T Set <T>(this IMemoryCacheManager cache, object key, T value, TimeSpan absoluteExpirationRelativeToNow) { var entry = cache.CreateEntry(key); entry.AbsoluteExpirationRelativeToNow = absoluteExpirationRelativeToNow; entry.Value = value; entry.Dispose(); return(value); }
public static T Set <T>(this IMemoryCacheManager cache, object key, T value, DateTimeOffset absoluteExpiration) { var entry = cache.CreateEntry(key); entry.AbsoluteExpiration = absoluteExpiration; entry.Value = value; entry.Dispose(); return(value); }
public GraphAuthentication(IOptions <GraphDetails> graph, IMemoryCacheManager memoryCacheManager) { var options = graph.Value; _host = options.Host; _tenant = options.Tenant; _client_id = options.Client_Id; _client_secret = options.Client_Secret; _scope = options.Scope; _memoryCacheManager = memoryCacheManager; }
public static TItem GetOrCreate <TItem>(this IMemoryCacheManager cache, object key, Func <ICacheEntry, TItem> factory) { if (!cache.TryGetValue(key, out var result)) { var entry = cache.CreateEntry(key); result = factory(entry); entry.SetValue(result); entry.Dispose(); } return((TItem)result); }
public static async Task <TItem> GetOrCreateAsync <TItem>(this IMemoryCacheManager cache, object key, Func <ICacheEntry, Task <TItem> > factory) { if (!cache.TryGetValue(key, out object result)) { var entry = cache.CreateEntry(key); result = await factory(entry); entry.SetValue(result); entry.Dispose(); } return((TItem)result); }
public GetMonitoringLoadingQueryHandler(IStorage storage, IServiceProvider serviceProvider) { _storage = storage; garmentCuttingOutRepository = storage.GetRepository <IGarmentCuttingOutRepository>(); garmentCuttingOutItemRepository = storage.GetRepository <IGarmentCuttingOutItemRepository>(); garmentLoadingRepository = storage.GetRepository <IGarmentLoadingRepository>(); garmentLoadingItemRepository = storage.GetRepository <IGarmentLoadingItemRepository>(); garmentPreparingRepository = storage.GetRepository <IGarmentPreparingRepository>(); garmentPreparingItemRepository = storage.GetRepository <IGarmentPreparingItemRepository>(); _http = serviceProvider.GetService <IHttpClientService>(); cacheManager = serviceProvider.GetService <IMemoryCacheManager>(); }
public static T Get <T>(this IMemoryCacheManager cacheManager, string key, Func <T> acquire, int cacheTime = 60) { if (cacheManager.IsSet(key)) { return(cacheManager.Get <T>(key)); } else { var result = acquire(); cacheManager.Set(key, result, cacheTime); return(result); } }
public static T Set <T>(this IMemoryCacheManager cache, object key, T value, MemoryCacheEntryOptions options) { using (var entry = cache.CreateEntry(key)) { if (options != null) { entry.SetOptions(options); } entry.Value = value; } return(value); }
public void Dispose() { SRefMultiple sref = _sizedRefMultiple; if (sref != null && Interlocked.CompareExchange(ref _sizedRefMultiple, null, sref) == sref) { sref.Dispose(); } IMemoryCacheManager memoryCacheManager = s_memoryCacheManager; if (memoryCacheManager != null) { memoryCacheManager.ReleaseCache(_memoryCache); } }
public void Dispose() { SRef comparand = this._sizedRef; if ((comparand != null) && (Interlocked.CompareExchange <SRef>(ref this._sizedRef, null, comparand) == comparand)) { comparand.Dispose(); } IMemoryCacheManager manager = s_memoryCacheManager; if (manager != null) { manager.ReleaseCache(this._memoryCache); } }
private static void InitMemoryCacheManager() { if (s_memoryCacheManager == null) { IMemoryCacheManager memoryCacheManager = null; IServiceProvider host = ObjectCache.Host; if (host != null) { memoryCacheManager = host.GetService(typeof(IMemoryCacheManager)) as IMemoryCacheManager; } if (memoryCacheManager != null) { Interlocked.CompareExchange(ref s_memoryCacheManager, memoryCacheManager, null); } } }
public RoleService(IUnitOfWork unitOfWork , IMemoryCacheManager memoryCacheManager , IRepository <sys_RoleMenu> repoRoleMenu , IRepository <sys_Menu> repoMenu , IRepository <sys_RolePermission> repoRolePermission , IRepository <sys_UserRole> repoUserRole , IRepository <sys_Role> repoRole) { this._memoryCacheManager = memoryCacheManager; this._repoRole = repoRole; this._repoRoleMenu = repoRoleMenu; this._repoMenu = repoMenu; this._repoUserRole = repoUserRole; this._repoRolePermission = repoRolePermission; this._unitOfWork = unitOfWork; }
public GetCategoriesHandler(IUnitOfWork unitOfWork, IMemoryCacheManager memoryCacheManager) : base(unitOfWork) { _memoryCacheManager = memoryCacheManager; }
public CoreData(ICoreHttpClientService http, IMemoryCacheManager cacheManager) { _http = http; _cacheManager = cacheManager; }
public MemoryInterceptorCacheHandler(IMemoryCacheManager cacheManager, ICacheExpiration cacheExpiration) : base(cacheManager, cacheExpiration) { }
public MemoryCacheFilesService(IMemoryCacheManager cacheManager) { this.cacheManager = cacheManager; }
public CoreData(IServiceProvider serviceProvider) { _http = serviceProvider.GetService <ICoreHttpClientService>(); _cacheManager = serviceProvider.GetService <IMemoryCacheManager>(); }
public CoreClient(IHttpClientService http, IServiceProvider serviceProvider) { _http = http; cacheManager = serviceProvider.GetService <IMemoryCacheManager>(); Token = GetTokenAsync().Result; }