/// <summary> /// Used internally only for unit testing. /// </summary> /// <param name="innerHandler">The inner handler to retrieve the content from on cache misses.</param> /// <param name="cacheExpirationPerHttpResponseCode">A mapping of HttpStatusCode to expiration times. If unspecified takes a default value.</param> /// <param name="cache">The distributed cache to use.</param> /// /// <param name="statsProvider">An <see cref="IStatsProvider"/> that records statistic information about the caching behavior.</param> internal RedisCacheHandler(HttpMessageHandler innerHandler, IDictionary<HttpStatusCode, TimeSpan> cacheExpirationPerHttpResponseCode, IDistributedCache cache, IStatsProvider statsProvider = null) : base(innerHandler ?? new HttpClientHandler()) { this.StatsProvider = statsProvider ?? new StatsProvider(nameof(RedisCacheHandler)); this.cacheExpirationPerHttpResponseCode = cacheExpirationPerHttpResponseCode ?? new Dictionary<HttpStatusCode, TimeSpan>(); responseCache = cache; }
public DynamicCacheShapeDisplayEvents( IDistributedCache distributedMemoryCache, ICacheContextManager cacheContextManager) { _distributedMemoryCache = distributedMemoryCache; _cacheContextManager = cacheContextManager; }
public CachingUserRepository( IDistributedCache cache, IUserRepository implementation) { this.cache = cache; this.implementation = implementation; }
public DistributedTreeCache( IDistributedCache cache, IOptions<TreeCacheOptions> optionsAccessor = null) { if (cache == null) { throw new ArgumentNullException(nameof(cache)); } this.cache = cache; options = optionsAccessor?.Value; if (options == null) options = new TreeCacheOptions(); //default }
public DistributedSession([NotNull] IDistributedCache cache, [NotNull] string sessionId, TimeSpan idleTimeout, [NotNull] Func<bool> tryEstablishSession, [NotNull] ILoggerFactory loggerFactory, bool isNewSessionKey) { _cache = cache; _sessionId = sessionId; _idleTimeout = idleTimeout; _tryEstablishSession = tryEstablishSession; _store = new Dictionary<EncodedKey, byte[]>(); _logger = loggerFactory.CreateLogger<DistributedSession>(); _isNewSessionKey = isNewSessionKey; }
public SwiftAuthManagerDistributedCache(IOptions<SwiftServiceOptions> options, IDistributedCache cache) { var _options = options.Value; Credentials = new SwiftCredentials { Endpoints = _options.Endpoints, Password = _options.Password, Username = _options.Username }; _cache = cache; }
/// <summary> /// Initializes a new instance of the <see cref="SitemapService" /> class. /// </summary> /// <param name="cacheProfileSettings">The cache profile settings.</param> /// <param name="distributedCache">The distributed cache for the application.</param> /// <param name="logger">The <see cref="SitemapService"/> logger.</param> /// <param name="urlHelper">The URL helper.</param> public SitemapService( IOptions<CacheProfileSettings> cacheProfileSettings, IDistributedCache distributedCache, ILogger<SitemapService> logger, IUrlHelper urlHelper) { CacheProfile cacheProfile = cacheProfileSettings.Value.CacheProfiles[CacheProfileName.SitemapNodes]; this.expirationDuration = TimeSpan.FromSeconds(cacheProfile.Duration.Value); this.distributedCache = distributedCache; this.logger = logger; this.urlHelper = urlHelper; }
public static IApplicationBuilder UseDistributedSession([NotNull] this IApplicationBuilder app, IDistributedCache cache, Action<SessionOptions> configure = null) { var loggerFactory = app.ApplicationServices.GetRequiredService<ILoggerFactory>(); return app.UseSession(options => { options.Store = new DistributedSessionStore(cache, loggerFactory); if (configure != null) { configure(options); } }); }
/// <summary> /// Initializes a new instance of <see cref="Tailspin.Surveys.TokenStorage.DistributedTokenCacheService"/> /// </summary> /// <param name="contextAccessor">An instance of <see cref="Microsoft.AspNetCore.Http.IHttpContextAccessor"/> used to get access to the current HTTP context.</param> /// <param name="loggerFactory"><see cref="Microsoft.Extensions.Logging.ILoggerFactory"/> used to create type-specific <see cref="Microsoft.Extensions.Logging.ILogger"/> instances.</param> /// <param name="dataProtectionProvider">An <see cref="Microsoft.AspNetCore.DataProtection.IDataProtectionProvider"/> for creating a data protector.</param> public DistributedTokenCacheService( IDistributedCache distributedCache, IHttpContextAccessor contextAccessor, ILoggerFactory loggerFactory, IDataProtectionProvider dataProtectionProvider) : base(loggerFactory) { Guard.ArgumentNotNull(distributedCache, nameof(distributedCache)); Guard.ArgumentNotNull(contextAccessor, nameof(contextAccessor)); Guard.ArgumentNotNull(dataProtectionProvider, nameof(dataProtectionProvider)); _distributedCache = distributedCache; _contextAccessor = contextAccessor; _dataProtectionProvider = dataProtectionProvider; }
public DistributedSessionStore(IDistributedCache cache, ILoggerFactory loggerFactory) { if (cache == null) { throw new ArgumentNullException(nameof(cache)); } if (loggerFactory == null) { throw new ArgumentNullException(nameof(loggerFactory)); } _cache = cache; _loggerFactory = loggerFactory; }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IDistributedCache cache) { var serverStartTimeString = DateTime.Now.ToString(); byte[] val = Encoding.UTF8.GetBytes(serverStartTimeString); cache.Set("lastServerStartTime", val); app.UseStartTimeHeader(); app.Run(async (context) => { context.Response.ContentType = "text/html"; await context.Response.WriteAsync("Hello World!"); }); }
public JsonNavigationTreeBuilder( IHostingEnvironment appEnv, IOptions<NavigationOptions> navigationOptionsAccessor, ILoggerFactory loggerFactory, IDistributedCache cache) { if(appEnv == null) { throw new ArgumentNullException(nameof(appEnv)); } if (loggerFactory == null) { throw new ArgumentNullException(nameof(loggerFactory)); } if (navigationOptionsAccessor == null) { throw new ArgumentNullException(nameof(navigationOptionsAccessor)); } this.appEnv = appEnv; navOptions = navigationOptionsAccessor.Value; logFactory = loggerFactory; log = loggerFactory.CreateLogger(typeof(JsonNavigationTreeBuilder).FullName); this.cache = cache; }
/// <summary> /// Initializes a new instance of the <see cref="SitemapService" /> class. /// </summary> /// <param name="cacheProfileSettings">The cache profile settings.</param> /// <param name="distributedCache">The distributed cache for the application.</param> /// <param name="logger">The <see cref="SitemapService"/> logger.</param> // $Start-ApplicationInsights$ /// <param name="telemetryClient">The Azure Application Insights telemetry client.</param> // $End-ApplicationInsights$ /// <param name="urlHelper">The URL helper.</param> public SitemapService( IOptions<CacheProfileSettings> cacheProfileSettings, IDistributedCache distributedCache, ILogger<SitemapService> logger, // $Start-ApplicationInsights$ TelemetryClient telemetryClient, // $End-ApplicationInsights$ IUrlHelper urlHelper) { CacheProfile cacheProfile = cacheProfileSettings.Value.CacheProfiles[CacheProfileName.SitemapNodes]; this.cacheSlidingExpiration = TimeSpan.FromSeconds(cacheProfile.Duration.Value); this.distributedCache = distributedCache; this.logger = logger; // $Start-ApplicationInsights$ this.telemetryClient = telemetryClient; // $End-ApplicationInsights$ this.urlHelper = urlHelper; }
/// <summary> /// Initializes a new instance of <see cref="Tailspin.Surveys.TokenStorage.DistributedTokenCache"/> /// </summary> /// <param name="claimsPrincipal">A <see cref="System.Security.Claims.ClaimsPrincipal"/> for the signed in user</param> /// <param name="distributedCache">An implementation of <see cref="Microsoft.Extensions.Caching.Distributed.IDistributedCache"/> in which to store the access tokens.</param> /// <param name="loggerFactory"><see cref="Microsoft.Extensions.Logging.ILoggerFactory"/> used to create type-specific <see cref="Microsoft.Extensions.Logging.ILogger"/> instances.</param> /// <param name="dataProtectionProvider">An <see cref="Microsoft.AspNet.DataProtection.IDataProtectionProvider"/> for creating a data protector.</param> public DistributedTokenCache( ClaimsPrincipal claimsPrincipal, IDistributedCache distributedCache, ILoggerFactory loggerFactory, IDataProtectionProvider dataProtectionProvider) : base() { Guard.ArgumentNotNull(claimsPrincipal, nameof(claimsPrincipal)); Guard.ArgumentNotNull(distributedCache, nameof(distributedCache)); Guard.ArgumentNotNull(loggerFactory, nameof(loggerFactory)); Guard.ArgumentNotNull(dataProtectionProvider, nameof(dataProtectionProvider)); _claimsPrincipal = claimsPrincipal; _cacheKey = BuildCacheKey(_claimsPrincipal); _distributedCache = distributedCache; _logger = loggerFactory.CreateLogger<DistributedTokenCache>(); _protector = dataProtectionProvider.CreateProtector(typeof(DistributedTokenCache).FullName); AfterAccess = AfterAccessNotification; LoadFromCache(); }
public DistributedCacheNavigationTreeBuilder( INavigationTreeBuilder implementation, IDistributedCache cache, IOptions<DistributedCacheNavigationTreeBuilderOptions> optionsAccessor, INavigationCacheKeyResolver cacheKeyResolver, ILogger<DistributedCacheNavigationTreeBuilder> logger) { if (implementation == null) { throw new ArgumentNullException(nameof(implementation)); } if(implementation is DistributedCacheNavigationTreeBuilder) { throw new ArgumentException("implementation cannot be an instance of DistributedCacheNavigationTreeBuilder"); } if (cache == null) { throw new ArgumentNullException(nameof(cache)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } if (optionsAccessor == null) { throw new ArgumentNullException(nameof(optionsAccessor)); } if (cacheKeyResolver == null) { throw new ArgumentNullException(nameof(cacheKeyResolver)); } this.implementation = implementation; this.cache = cache; log = logger; options = optionsAccessor.Value; this.cacheKeyResolver = cacheKeyResolver; }
public DistributedSession( IDistributedCache cache, string sessionId, TimeSpan idleTimeout, Func<bool> tryEstablishSession, ILoggerFactory loggerFactory, bool isNewSessionKey) { if (cache == null) { throw new ArgumentNullException(nameof(cache)); } if (string.IsNullOrEmpty(sessionId)) { throw new ArgumentException(Resources.ArgumentCannotBeNullOrEmpty, nameof(sessionId)); } if (tryEstablishSession == null) { throw new ArgumentNullException(nameof(tryEstablishSession)); } if (loggerFactory == null) { throw new ArgumentNullException(nameof(loggerFactory)); } _cache = cache; _sessionId = sessionId; _idleTimeout = idleTimeout; _tryEstablishSession = tryEstablishSession; _store = new Dictionary<EncodedKey, byte[]>(); _logger = loggerFactory.CreateLogger<DistributedSession>(); _isNewSessionKey = isNewSessionKey; }
public AccountController(SignInManager <User> signIn, IDistributedCache cache) { _signIn = signIn; this._cache = cache; }
public CustomerCacheReponsitory(IDistributedCache cache, IOptions <CustomerSettings> settings) : base(cache, KeyPrefix) { _setting = settings.Value; }
public SqlCachingController(IDistributedCache distributedCache) { _memoryCache = distributedCache; }
protected void Initialize(IDistributedCache distributedCache) { _distributedCache = distributedCache; }
public DistributedCacheFactory(IDistributedCache cache, ICacheSerializer serializer) { _cache = Guard.ArgumentNotNull(cache, nameof(cache)); _serializer = Guard.ArgumentNotNull(serializer, nameof(serializer)); }
public LoggedUsersDistributedStorage(IDistributedCache distributedCache, CacheKeyCreator cacheKeyCreator) { _distributedCache = distributedCache; _cacheKeyCreator = cacheKeyCreator; }
public CacheCaptchaStore(IDistributedCache <Captcha> cache) { Cache = cache; }
public DistributedHttpCache(IDistributedCache cache) => _cache = cache;
public FeatureValueCacheItemInvalidator(IDistributedCache <FeatureValueCacheItem> cache) { Cache = cache; }
public HomeController(IDistributedCache cache, IConnectionMultiplexer conn) { _cache = cache; _conn = conn; }
public TestController(IDistributedCache cache) { this.cache = cache; }
public CookieService(CookieContext context, IDistributedCache cache = null) { _context = context; _cache = cache; }
public ScopedDistributedCache(IDistributedCache distributedCache) { _distributedCache = distributedCache; }
public CacheManager(IDistributedCache cache) { _cache = cache; options = new DistributedCacheEntryOptions(); options.SetAbsoluteExpiration(DateTimeOffset.UtcNow.AddMinutes(30)); }
// ReSharper disable once SuggestBaseTypeForParameter public Yandere(IYandereApi api, IDistributedCache cache) : base(api, _sourceBooru, cache) { }
public WaterTemperatureCache(IDistributedCache cache) : base(cache) { }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IApplicationLifetime appLifetime, IDistributedCache cache) { loggerFactory.AddConsole(Configuration.GetSection("Logging")); loggerFactory.AddDebug(); loggerFactory.AddSerilog(); Log.Logger = new LoggerConfiguration() .WriteTo .ApplicationInsightsTraces(Configuration["ApplicationInsights:InstrumentationKey"]) .CreateLogger(); app.UseApplicationInsightsRequestTelemetry(); appLifetime.ApplicationStopped.Register(Log.CloseAndFlush); app.UseExceptionHandler( builder => { builder.Run(context => { context.Response.StatusCode = (int)HttpStatusCode.InternalServerError; context.Response.ContentType = "application/json"; return(Task.FromResult(0)); } ); } ); var jwtAppSettingOptions = Configuration.GetSection(nameof(JwtIssuerOptions)); var tokenValidationParameters = new TokenValidationParameters { ValidateIssuer = true, ValidIssuer = jwtAppSettingOptions[nameof(JwtIssuerOptions.Issuer)], ValidateAudience = true, ValidAudience = jwtAppSettingOptions[nameof(JwtIssuerOptions.Audience)], ValidateIssuerSigningKey = true, IssuerSigningKey = _key, RequireExpirationTime = false, ValidateLifetime = false, ClockSkew = TimeSpan.Zero }; app.UseJwtBearerAuthentication(new JwtBearerOptions { AutomaticAuthenticate = true, AutomaticChallenge = true, TokenValidationParameters = tokenValidationParameters }); app.UseSimpleInjectorAspNetRequestScoping(_container); _container.Options.DefaultScopedLifestyle = new AspNetRequestLifestyle(); ConfigureCache(env); ConfigureAzureStorage(env); RegisterServices(app); ConfigureHash(); InitializeContainer(app); RegisterDbContext <VotingContext>(Configuration.GetConnectionString("DefaultConnection")); RegisterAutomapper(); BuildMediator(); _container.Verify(); app.UseMvc(); // Enable middleware to serve generated Swagger as a JSON endpoint app.UseSwagger(); // Enable middleware to serve swagger-ui assets (HTML, JS, CSS etc.) app.UseSwaggerUi(); }
public RestoreCachedRequestParameters(IDistributedCache cache) => _cache = cache;
public StartTimeHeader(RequestDelegate next, IDistributedCache cache) { _next = next; _cache = cache; }
/// <summary> /// Creates a new <see cref="DistributedCacheTagHelperStorage"/>. /// </summary> /// <param name="distributedCache">The <see cref="IDistributedCache"/> to use.</param> public DistributedCacheTagHelperStorage(IDistributedCache distributedCache) { _distributedCache = distributedCache; }
/// <summary> /// 初始化一个<see cref="OnlineUserProvider{TUser, TUserKey, TUserClaim, TUserClaimKey, TRole, TRoleKey}"/>类型的新实例 /// </summary> public OnlineUserProvider(IServiceProvider serviceProvider) { _serviceProvider = serviceProvider; _cache = serviceProvider.GetService <IDistributedCache>(); }
public UserController(DBContext context, IDistributedCache memoryCache) { _context = context; _memoryCache = memoryCache; }
public ProjectQuery(IDatabaseSet databaseSet, IDistributedCache redisCache, IMapper mapper) : base(databaseSet, redisCache, mapper) { }
public BookStoreController(IBookManager bookManager, IDistributedCache distributedCache, ILoggerFactory factory) { this.bookManager = bookManager; this.distributedCache = distributedCache; this.logger = factory.CreateLogger("BookCategory"); }
public static async Task<T> GetUsingBytesAsync<T>(this IDistributedCache distributedCache, string key, CancellationToken token = default(CancellationToken)) => (await distributedCache.GetAsync(key, token)).Get<T>();
/// <summary> /// Constructor /// </summary> public ConsentPersonCache(IGdprCapability gdprCapability, IDistributedCache cache) : base(gdprCapability.PersonConsentService, cache) { }
public static T GetUsingJson<T>(this IDistributedCache distributedCache) => distributedCache.GetUsingJson<T>(typeof(T).FullName);
public HomeController(IDistributedCache cacheMechanism) { this.cacheMechanism = cacheMechanism; }
public static T GetUsingJson<T>(this IDistributedCache distributedCache, string key) => JsonConvert.DeserializeObject<T>(distributedCache.GetString(key));
public BookService(IBookRepository repository, IDistributedCache distributedCache) { this.BookRepository = repository; this.DistributedCache = distributedCache; }
public JobNameRepository(IDistributedCache distributedCache, IRepositoryAsync <JobName> repository) { _distributedCache = distributedCache; _repository = repository; }
public DefaultDynamicCache(IDistributedCache distributedCache) { _distributedCache = distributedCache; }
public HomeController(ILogger <HomeController> logger, IDistributedCache distributedCache) { _logger = logger; cache = distributedCache; }
public DataCategoriesAccessor(CommonDbContext _dbContext, IDistributedCache _DistributedCache) : base(_dbContext, _DistributedCache) { dbContext = _dbContext; }
public static async Task<T> GetUsingBytesAsync<T>(this IDistributedCache distributedCache, CancellationToken token = default(CancellationToken)) => await distributedCache.GetUsingBytesAsync<T>(typeof(T).FullName, token);
public DistributedSessionStore([NotNull] IDistributedCache cache, [NotNull] ILoggerFactory loggerFactory) { _cache = cache; _loggerFactory = loggerFactory; }
public RedisCacheTagHelper(IDistributedCache redisCache) { _redisCache = redisCache; }
public CacheContext() { Local = A.Fake<ILocalCache>(); Distributed = A.Fake<IDistributedCache>(); LocalCache.StaticProvider = Local; DistributedCache.StaticProvider = Distributed; }