internal StandardCachingStrategyBase(int?maxResults, ICachingProvider cachingProvider) : base(maxResults, cachingProvider) { WriteThroughCachingEnabled = true; GenerationalCachingEnabled = true; Partition = null; }
public L2CacheTest() { IServiceCollection services = new ServiceCollection(); services.AddMemoryServices(options => { options.DBConfig.SizeLimit = 100; options.DBConfig.ExpirationScanFrequency = 10; }); services.AddRedisServices(options => { options.DBConfig.Password = "******"; options.DBConfig.Endpoints.Add(new Cache.Core.Configurations.ServerEndPoint() { Port = 6379, Host = "r-wz952aaada291544pd.redis.rds.aliyuncs.com" }); }).AddRedisL2Services() ; services.AddLogging(); IServiceProvider serviceProvider = services.BuildServiceProvider(); ICachingProviderFactory _factory = serviceProvider.GetService <ICachingProviderFactory>(); _provider = _factory.GetCachingProvider(CachingConstValue.DefaultInMemoryName); _redis = _factory.GetCachingProvider(CachingConstValue.DefaultRedisName); _l2CacheProvider = serviceProvider.GetService <IL2CacheProvider>(); _defaultTs = TimeSpan.FromSeconds(600); }
public EngineHandler( IOptions <RazorLightOptions> options, IRazorTemplateCompiler compiler, ITemplateFactoryProvider factoryProvider, ICachingProvider cache) : this(options.Value, compiler, factoryProvider, cache) { }
public ICompoundKeyCachingStrategy <T> GetCompoundKeyInstance <T>(ICachingProvider cachingProvider) where T : class, new() { // load up the factory if it exists and use it var factory = (IConfigCachingStrategyFactory)Activator.CreateInstance(Factory, this); return(factory.GetCompoundKeyInstance <T>(cachingProvider)); }
public NotesLoader(IAppUser user, ICachingProvider cachor, IOptions <DomainOptions> opt, /*INotesReader reader,*/ ReaderConnection readerCon) { _user = user; _cachor = cachor; _opt = opt; //_reader = reader; _conReader = readerCon; }
internal CompoundKeyCachingStrategyCommon(int?maxResults, ICachingProvider cachingProvider) { CachePrefix = DefaultRepositoryConventions.CachePrefix; CachingProvider = cachingProvider; MaxResults = maxResults; TypeFullName = typeof(T).FullName ?? typeof(T).Name; // sometimes FullName returns null in certain derived type situations, so I added the check to use the Name property if FullName is null }
public HomeController(ICachingProviderFactory providerFactory, IL2CacheProvider l2CacheProvider) { _providerFactory = providerFactory; _l2CacheProvider = l2CacheProvider; _memoryProvider = _providerFactory.GetCachingProvider(CachingConstValue.DefaultInMemoryName); _redisProvider = _providerFactory.GetCachingProvider(CachingConstValue.DefaultRedisName); }
public RedisAndMemoryProvider(ICachingProviderFactory providerFactory , ILoggerFactory loggerFactory = null) { _providerFactory = providerFactory; _memoryProvider = _providerFactory.GetCachingProvider(CachingConstValue.DefaultInMemoryName); _redisProvider = _providerFactory.GetCachingProvider(CachingConstValue.DefaultRedisName); _logger = loggerFactory?.CreateLogger <RedisAndMemoryProvider>(); }
public CachingBehavior(ICachingProvider cachingProvider, ILogger logger) { Guard.ArgumentIsNotNull(cachingProvider, "cachingProvider"); Guard.ArgumentIsNotNull(logger, "logger"); _cachingProvider = cachingProvider; _logger = logger; }
public AccountController(IMapper mapper, IAccountStore accountStoreService, ICachingProvider cachingProvider, ILogger <AccountController> logger, IOptions <JWTConfig> jwtOptions) { _mapper = mapper; _accountStoreService = accountStoreService; _caching = cachingProvider.CreateCaching(); _logger = logger; _jwtConfig = jwtOptions.Value; }
public Server(ICachingProvider cachingProvider, string ip, int port) { _cachingProvider = cachingProvider; IPAddress localAddr = IPAddress.Parse(ip); server = new TcpListener(localAddr, port); server.Start(); StartListener(); }
public PermissionStorageService( ICachingProvider cacheFactory, IHttpContextAccessor httpContextAccessor, ISysResourceService resourceService) { _cacheFactory = cacheFactory; _httpContextAccessor = httpContextAccessor; _resourceService = resourceService; }
public AlliterationsProvider( IAlliterationOptionsFactory alliterationOptionsFactory, IRandomNumberGenerator randomNumberGenerator, ICachingProvider cachingProvider) { this.alliterationOptionsFactory = alliterationOptionsFactory; this.randomNumberGenerator = randomNumberGenerator; this.cachingProvider = cachingProvider; }
/// <summary> /// Initializes a new instance of the <see cref="BlogPostTasks"/> class. /// </summary> /// <param name="blogPostSpecificationFactory"> /// The blog post specification factory. /// </param> /// <param name="blogPostRepository"> /// The blog post repository. /// </param> /// <param name="cachingProvider"> /// The caching provider. /// </param> public BlogPostTasks( IBlogPostSpecificationFactory blogPostSpecificationFactory, IBlogPostRepository blogPostRepository, ICachingProvider cachingProvider) { this.blogPostSpecificationFactory = blogPostSpecificationFactory; this.blogPostRepository = blogPostRepository; this.cachingProvider = cachingProvider; }
/// <summary> /// Returns the cached result if exists, or will execute the query and add the result in cache. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="query"></param> /// <param name="slidingExpiration"></param> /// <returns></returns> public static IEnumerable <T> FromCache <T>(this IQueryable <T> query, TimeSpan expiration) { string key = query.GetKey(); ICachingProvider provider = ProviderManager.Provider; provider.Get(out IEnumerable <T> result, key, expiration, query); return(result); }
public CachedSettingProvider(ISettingProvider settingProvider, ICachingProvider cachingProvider, TimeSpan defaultAbsoluteExpiration) { Guard.ArgumentIsNotNull(settingProvider, "settingProvider"); Guard.ArgumentIsNotNull(cachingProvider, "cachingProvider"); _settingProvider = settingProvider; _cachingProvider = cachingProvider; _defaultAbsoluteExpiration = defaultAbsoluteExpiration; }
public CacheRepositoryConfiguration(string name, string prefix, ICachingProvider cachingProviderInstance, string cachingStrategy = null, string cachingProvider = null) : base(name) { Prefix = prefix; CachingStrategy = cachingStrategy; CachingProvider = cachingProvider; CachingProviderInstance = cachingProviderInstance; Factory = typeof(CacheConfigRepositoryFactory); }
public Toolbox(IOptions <DomainOptions> options, ICachingProvider cachor, IUnitOfWork <CPDbContext> reader, IIndex <DomainSetter, IDomainSetter> domainSetter, IMapper mapper, IEventSender sender) { Options = options; Cachor = cachor; Reader = reader; DomainSetter = domainSetter; Mapper = mapper; Sender = sender; }
/// <summary> /// Initializes a new instance of the <see cref="ServiceValidatorBase" /> class. /// </summary> /// <param name="unitOfWork">The unit of work.</param> /// <param name="authenticationProvider">The authentication provider.</param> /// <param name="messageProvider">The message provider.</param> /// <param name="cachingProvider">The caching provider.</param> /// <param name="serializationProvider">The serialization provider.</param> public ServiceValidatorBase( IUnitOfWork unitOfWork, IAuthenticationProvider authenticationProvider, IMessageProvider messageProvider, ICachingProvider cachingProvider, ISerializationProvider serializationProvider) : base(unitOfWork, authenticationProvider, messageProvider, cachingProvider, serializationProvider) { }
public CachedServiceClient(IServiceClient serviceClient, ICachingProvider cachingProvider, TimeSpan defaultAbsoluteExpiration) { Guard.ArgumentIsNotNull(serviceClient, "serviceClient"); Guard.ArgumentIsNotNull(cachingProvider, "cachingProvider"); _serviceClient = serviceClient; _cachingProvider = cachingProvider; _defaultAbsoluteExpiration = defaultAbsoluteExpiration; }
/// <summary> /// Initializes a new instance of the <see cref="UserController"/> class. /// </summary> /// <param name="userSaveDetailsMapper"> /// The user save details mapper. /// </param> /// <param name="userTasks"> /// The user tasks. /// </param> /// <param name="cachingProvider"> /// The caching provider. /// </param> /// <param name="userSignOnDetailsMapper"> /// The user Sign On Details Mapper. /// </param> public UserController( IUserSaveDetailsMapper userSaveDetailsMapper, IUserTasks userTasks, ICachingProvider cachingProvider, IUserSignOnDetailsMapper userSignOnDetailsMapper) { this.userSaveDetailsMapper = userSaveDetailsMapper; this.userTasks = userTasks; this.cachingProvider = cachingProvider; this.userSignOnDetailsMapper = userSignOnDetailsMapper; }
public virtual RazorLightEngineBuilder UseCachingProvider(ICachingProvider provider) { if (provider == null) { throw new ArgumentNullException(nameof(provider)); } cachingProvider = provider; return(this); }
public RazorLightEngine( RazorLightOptions options, IRazorTemplateCompiler templateCompiler, ITemplateFactoryProvider factoryProvider, ICachingProvider cachingProvider) { Options = options ?? throw new ArgumentNullException(nameof(options)); TemplateFactoryProvider = factoryProvider ?? throw new ArgumentNullException(nameof(factoryProvider)); TemplateCompiler = templateCompiler ?? throw new ArgumentNullException(nameof(templateCompiler)); TemplateCache = cachingProvider; }
public Reddit(IListingFilter listingFilter, UserState userState, IActionDeferralSink deferalSink, ICaptchaProvider captchaProvider, string appId = null, string appSecret = null, string redirectUrl = null, ICachingProvider cacheProvider = null, INetworkLayer networkLayer = null) { _cacheProvider = cacheProvider; _networkLayer = networkLayer ?? new NetworkLayer(userState, appId, appSecret, redirectUrl); _listingFilter = listingFilter; _userState = userState ?? new UserState(); _deferalSink = deferalSink; _captchaProvider = captchaProvider; _appId = appId; _appSecret = appSecret; _redirectUrl = redirectUrl; }
public EngineHandler( RazorLightOptions options, IRazorTemplateCompiler compiler, ITemplateFactoryProvider factoryProvider, ICachingProvider cache) { Options = options ?? throw new ArgumentNullException(nameof(options)); Compiler = compiler ?? throw new ArgumentNullException(nameof(compiler)); FactoryProvider = factoryProvider ?? throw new ArgumentNullException(nameof(factoryProvider)); Cache = cache; }
public override ICompoundKeyCachingStrategy <T> GetCompoundKeyInstance <T>(ICachingProvider cachingProvider) { if (!Int32.TryParse(CachingStrategyConfiguration["timeout"], out int timeout)) { throw new ConfigurationErrorsException("The timeout attribute is required in order to use the TimeoutCachingStrategy via the configuration file."); } return(new TimeoutCompoundKeyCachingStrategy <T>(timeout, cachingProvider) { MaxResults = CachingStrategyConfiguration.MaxResults }); }
/// <summary> /// Initializes a new instance of the <see cref="ServiceBase" /> class. /// </summary> /// <param name="unitOfWork">The unit of work.</param> /// <param name="authenticationProvider">The authentication provider.</param> /// <param name="messageProvider">The message provider.</param> /// <param name="cachingProvider">The caching provider.</param> /// <param name="serializationProvider">The serialization provider.</param> public ServiceBase( IUnitOfWork unitOfWork, IAuthenticationProvider authenticationProvider, IMessageProvider messageProvider, ICachingProvider cachingProvider, ISerializationProvider serializationProvider) { this.UnitOfWork = unitOfWork; this.AuthenticationProvider = authenticationProvider; this.MessageProvider = messageProvider; this.CachingProvider = cachingProvider; this.SerializationProvider = serializationProvider; }
public CachingInterceptor(ICachingProvider cachingProvider, IDateTimeProvider dateTimeProvider) { if (cachingProvider == null) { throw new ArgumentNullException(nameof(cachingProvider)); } if (dateTimeProvider == null) { throw new ArgumentNullException(nameof(dateTimeProvider)); } this.cachingProvider = cachingProvider; this.dateTimeProvider = dateTimeProvider; }
public async Task GetSetTest() { var c = ContainerHelper.Builder(); ICachingProvider _cp = c.Resolve <ICachingProvider>(); var val = await _cp.Get("a", async() => { await Task.CompletedTask; return("aab"); }); Assert.AreEqual(val, "aab"); }
protected override IController GetControllerInstance(System.Web.Routing.RequestContext requestContext, Type controllerType) { if (controllerType == typeof(BlogController)) { PersonalWebsiteContext context = new PersonalWebsiteContext(); _provider = _provider ?? new CachingProvider(); BlogRepository repo = new BlogRepository(context, _provider); return new BlogController(repo); } else if (controllerType == typeof(ErrorController)) { return new ErrorController(new SqlLoggingRepository()); } else return base.GetControllerInstance(requestContext, controllerType); }
private static ICachingProvider GetCurrentProvider() { const string message = @"Unable to perform caching. No cache provider has been specified."; if (_currentProvider == null) { throw new InvalidOperationException(message); } ICachingProvider cachingProvider = _currentProvider(); if (cachingProvider == null) { throw new InvalidOperationException(message); } return(cachingProvider); }
/// <summary> /// 设置缓存供应器。 /// </summary> /// <param name="provider">供应器。</param> /// <param name="level">缓存层级。</param> /// <returns></returns> public static void RegisterProvider(ICachingProvider provider, Level level = Level.First) { if (provider is null) { throw new ArgumentNullException(nameof(provider)); } switch (level) { case Level.First: case Level.Second: case Level.Third: CacheProvider[level] = provider; break; default: throw new NotSupportedException(); } }
public RazorLightEngine( RazorLightOptions options, ITemplateFactoryProvider factoryProvider, ICachingProvider cachingProvider) { if (options == null) { throw new ArgumentNullException(nameof(options)); } if (factoryProvider == null) { throw new ArgumentNullException(nameof(factoryProvider)); } Options = options; templateFactoryProvider = factoryProvider; cache = cachingProvider; }
public MultiServerCachePrefixManager(ICachingProvider cachingProvider, string key = "#Repos/GlobalCacheCounter") { _cachingProvider = cachingProvider; _key = key; }
public WebOutputCacheAttrribute() { this.cachingProvider = ServiceLocator.Current.GetInstance<ICachingProvider>(); }
public TagTasks(ICachingProvider cachingProvider) { this.cachingProvider = cachingProvider; }
//Our composition Root protected void Application_Start() { AreaRegistration.RegisterAllAreas(); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); var emailConfig = ConfigurationManager.GetSection("EmailLogger") as EmailLogConfiguration; //Ensure Web.Config is correctly configured. if (emailConfig == null) throw new ConfigurationErrorsException("Email Logger was not configured correctly"); ILogger emailLoggingProvider = new EmailLogger(emailConfig); SqlLoggingRepository sqlLogRepo = new SqlLoggingRepository(); ILogger sqlLoggingProvider = new SqlLogger(sqlLogRepo); Global.Logger = new LoggingService(sqlLoggingProvider, emailLoggingProvider); string userName = ConfigurationManager.AppSettings["AdminDefaultUserName"]; if (Membership.FindUsersByName(userName).Count == 0) { string password = ConfigurationManager.AppSettings["AdminDefaultPassword"]; string email = ConfigurationManager.AppSettings["AdminDefaultEmail"]; MembershipCreateStatus createStatus; Membership.CreateUser(userName, password, email, passwordQuestion: null, passwordAnswer: null, isApproved: true, providerUserKey: null, status: out createStatus); if (createStatus != MembershipCreateStatus.Success) throw new MembershipCreateUserException(createStatus.ToString()); } var unhandledErrorAttr = new LoggingHandleErrorAttribute(Global.Logger); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters, new object[] { unhandledErrorAttr }); Database.SetInitializer<PersonalWebsiteContext>(new ContextInitializer()); _cache = new CachingProvider(); var controllerFactory = new PersonalWebsiteControllerFactory(_cache); ControllerBuilder.Current.SetControllerFactory(controllerFactory); }
public PersonalWebsiteControllerFactory(ICachingProvider provider) { _provider = provider; }
/// <summary> /// Initializes a new instance of the <see cref="PostController"/> class. /// </summary> /// <param name="blogTasks"> /// The blog tasks. /// </param> /// <param name="blogPostSaveDetailsMapper"> /// The blog post save details mapper. /// </param> /// <param name="blogPostPageViewModelMapper"> /// The blog post page view model mapper. /// </param> /// <param name="identityService"> /// The identity Service. /// </param> /// <param name="blogPostCommentSaveDetailsMapper"> /// The blog Post Comment Save Details Mapper. /// </param> /// <param name="cachingProvider"> /// The caching provider. /// </param> public PostController( IBlogTasks blogTasks, IBlogPostSaveDetailsMapper blogPostSaveDetailsMapper, IBlogPostPageViewModelMapper blogPostPageViewModelMapper, IIdentityService identityService, IBlogPostCommentSaveDetailsMapper blogPostCommentSaveDetailsMapper, ICachingProvider cachingProvider) { this.blogTasks = blogTasks; this.cachingProvider = cachingProvider; this.blogPostSaveDetailsMapper = blogPostSaveDetailsMapper; this.blogPostPageViewModelMapper = blogPostPageViewModelMapper; this.identityService = identityService; this.blogPostCommentSaveDetailsMapper = blogPostCommentSaveDetailsMapper; }
/// <summary> /// Create a new readonly view (and copy) of the given configuration. /// </summary> /// <param name="config">the configuration to copy.</param> public ReadOnlyTemplateServiceConfiguration(ITemplateServiceConfiguration config) { if (config == null) { throw new ArgumentNullException("config"); } _allowMissingPropertiesOnDynamic = config.AllowMissingPropertiesOnDynamic; _activator = config.Activator; if (_activator == null) { throw new ArgumentNullException("config", "the configured Activator cannot be null!"); } _baseTemplateType = config.BaseTemplateType; // Check if the baseTemplateType is valid. if (_baseTemplateType != null && (!typeof(ITemplate).IsAssignableFrom(_baseTemplateType) || typeof(ITemplate) == _baseTemplateType)) { throw new ArgumentOutOfRangeException("config", "the configured BaseTemplateType must implement ITemplate!"); } _cachingProvider = config.CachingProvider; if (_cachingProvider == null) { throw new ArgumentNullException("config", "the configured CachingProvider cannot be null!"); } #if !RAZOR4 #pragma warning disable 0618 // Backwards Compat. _codeInspectors = config.CodeInspectors; if (_codeInspectors == null) { throw new ArgumentNullException("config", "the configured CodeInspectos cannot be null!"); } _codeInspectors = new List<ICodeInspector>(_codeInspectors); #pragma warning restore 0618 // Backwards Compat. #endif _compilerServiceFactory = config.CompilerServiceFactory; if (_compilerServiceFactory == null) { throw new ArgumentNullException("config", "the configured CompilerServiceFactory cannot be null!"); } _debug = config.Debug; _disableTempFileLocking = config.DisableTempFileLocking; _encodedStringFactory = config.EncodedStringFactory; if (_encodedStringFactory == null) { throw new ArgumentNullException("config", "the configured EncodedStringFactory cannot be null!"); } _language = config.Language; _namespaces = config.Namespaces; if (_namespaces == null) { throw new ArgumentNullException("config", "the configured Namespaces cannot be null!"); } _namespaces = new HashSet<string>(_namespaces); _referenceResolver = config.ReferenceResolver; if (_referenceResolver == null) { throw new ArgumentNullException("config", "the configured ReferenceResolver cannot be null!"); } #pragma warning disable 0618 // Backwards Compat. _resolver = config.Resolver; _templateManager = config.TemplateManager; if (_templateManager == null) { if (_resolver != null) { _templateManager = new Xml.WrapperTemplateManager(_resolver); } else { throw new ArgumentNullException("config", "the configured TemplateManager and Resolver cannot be null!"); } } #pragma warning restore 0618 // Backwards Compat. }
///<Summary> /// Either use a Unit of Work, or manually ensure all Repos share the same context. ///</Summary> public BlogRepository(PersonalWebsiteContext context, ICachingProvider cache) { _context = context; _cache = cache; }
/// <summary> /// Initializes a new instance of the <see cref="BlogController"/> class. /// </summary> /// <param name="blogTasks"> /// The blog tasks. /// </param> /// <param name="blogPostTasks"> /// The blog Post Tasks. /// </param> /// <param name="blogSaveDetailsMappper"> /// The blog Save Details Mappper. /// </param> /// <param name="blogPageViewModelMapper"> /// The blog Page View Model Mapper. /// </param> /// <param name="blogPostListPageViewModelMapper"> /// The blog Post List Page View Model Mapper. /// </param> /// <param name="blogPostArchivePageViewModelMapper"> /// The blog Post Archive Page View Model Mapper. /// </param> /// <param name="identityService"> /// The identity Service. /// </param> /// <param name="cachingProvider"> /// The caching provider. /// </param> /// <param name="blogUserPageViewModelMapper"> /// The blog User Page View Model Mapper. /// </param> public BlogController( IBlogTasks blogTasks, IBlogPostTasks blogPostTasks, IBlogSaveDetailsMappper blogSaveDetailsMappper, IBlogPageViewModelMapper blogPageViewModelMapper, IBlogPostListPageViewModelMapper blogPostListPageViewModelMapper, IBlogPostArchivePageViewModelMapper blogPostArchivePageViewModelMapper, IIdentityService identityService, ICachingProvider cachingProvider, IBlogUserPageViewModelMapper blogUserPageViewModelMapper) { this.blogTasks = blogTasks; this.blogUserPageViewModelMapper = blogUserPageViewModelMapper; this.identityService = identityService; this.cachingProvider = cachingProvider; this.blogPostTasks = blogPostTasks; this.blogSaveDetailsMappper = blogSaveDetailsMappper; this.blogPageViewModelMapper = blogPageViewModelMapper; this.blogPostListPageViewModelMapper = blogPostListPageViewModelMapper; this.blogPostArchivePageViewModelMapper = blogPostArchivePageViewModelMapper; }
private static void LoadTagsIntoCache(IReferenceDataRepository referenceDataRepository, ICachingProvider cachingProvider) { var rootTag = referenceDataRepository.FindAll<Tag>().First(x => x.Parent == null); cachingProvider.Insert(rootTag); }
/// <summary> /// Initializes a new instance of the <see cref="BlogTasks"/> class. /// </summary> /// <param name="blogRepository"> /// The blog repository. /// </param> /// <param name="blogSpecificationFactory"> /// The blog specifications factory. /// </param> /// <param name="blogMapper"> /// The blog Mapper. /// </param> /// <param name="blogPostMapper"> /// The blog Post Mapper. /// </param> /// <param name="identityService"> /// The identity Service. /// </param> /// <param name="blogPostCommentMapper"> /// The blog Post Comment Mapper. /// </param> /// <param name="cachingProvider"> /// The caching provider. /// </param> public BlogTasks( IBlogRepository blogRepository, IBlogSpecificationFactory blogSpecificationFactory, IBlogMapper blogMapper, IBlogPostMapper blogPostMapper, IIdentityService identityService, IBlogPostCommentMapper blogPostCommentMapper, ICachingProvider cachingProvider) { this.blogRepository = blogRepository; this.blogSpecificationFactory = blogSpecificationFactory; this.blogMapper = blogMapper; this.blogPostMapper = blogPostMapper; this.identityService = identityService; this.blogPostCommentMapper = blogPostCommentMapper; this.cachingProvider = cachingProvider; }