public RedisFactory(IOptionsMonitor <RedisOptions> optionsMonitor) { _optionsMonitor = optionsMonitor; optionsMonitor.OnChange((_, name) => _connectionMultiplexers.TryRemove(name, out var _)); }
/// <summary> /// Initializes a new instance of the <see cref="CorrelationIdContextProvider"/> class. /// </summary> /// <param name="httpContextAccessor">The http context accessor used to retreive the correlation id.</param> /// <param name="options">Options containing the name of the correlation id header.</param> public CorrelationIdContextProvider(IHttpContextAccessor httpContextAccessor, IOptionsMonitor <CorrelationIdContextProviderOptions> options = null) : this(httpContextAccessor?.HttpContext?.GetCorrelationIdAccessor(options?.CurrentValue.CorrelationIdHeader ?? CorrelationId)) { }
public CustomFormatter(IOptionsMonitor <CustomOptions> options) : base("custom") { ReloadLoggerOptions(options.CurrentValue); _optionsReloadToken = options.OnChange(ReloadLoggerOptions); }
public DefaultDapperFactory(IServiceProvider services, IOptionsMonitor <DapperFactoryOptions> optionsMonitor) { _services = services ?? throw new ArgumentNullException(nameof(services)); _optionsMonitor = optionsMonitor ?? throw new ArgumentNullException(nameof(optionsMonitor)); }
public ApiAuthHandler(IOptionsMonitor <ApiAuthOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock, ApiClientFactory factory) : base(options, logger, encoder, clock) { Factory = factory; }
public SingleLineConsoleLoggerProvider(IOptionsMonitor <SingleLineConsoleLoggerOptions> options) { _options = options; _optionsReloadToken = _options.OnChange(ReloadOptions); _sink = new SingleLineConsoleLoggerSink(_options.CurrentValue); }
public ConfigurationOptionsMonitorService(IOptionsMonitor <Settings> optionsMonitor) { _optionsMonitor = optionsMonitor; }
public BasicAuthenticationHandler(IApiSignInManager apiSignInManager, IUserManager userManager, IOptionsMonitor <BasicAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock) { _apiSignInManager = apiSignInManager; _userManager = userManager; }
public MongoPatchbotGameStore(IMongoConnection databaseConnection, IOptionsMonitor <DatabaseOptions> databaseOptions, IHostApplicationLifetime hostLifetime, ILogger <MongoPatchbotGameStore> log, IEntityCache <string, PatchbotGame> patchbotGameCache, IOptionsMonitor <CachingOptions> cachingOptions) : base(databaseConnection, databaseOptions, hostLifetime, log) { this._patchbotGameCache = patchbotGameCache; this._log = log; this._cachingOptions = cachingOptions; base.MongoConnection.ClientChanged += OnClientChanged; OnClientChanged(base.MongoConnection.Client); }
public QQHandler(IOptionsMonitor <QQOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock) { }
public ChiyaProxyHttp2HandlerBuilder(IServiceProvider services, IOptionsMonitor <ProxyOptions> options, ILogger <ChiyaProxyHttp2HandlerBuilder> logger) { _services = services; _options = options; _logger = logger; }
public async Task <IActionResult> Create(CourseCreateInputModel inputModel, [FromServices] IAuthorizationService authorizationService, [FromServices] IEmailClient emailClient, [FromServices] IOptionsMonitor <UsersOptions> usersOptions) { if (ModelState.IsValid) { try { CourseDetailViewModel course = await courseService.CreateCourseAsync(inputModel); // Per non inserire logica nel controller, potremmo spostare questo blocco all'interno del metodo CreateCourseAsync del servizio applicativo // ...ma attenzione a non creare riferimenti circolari! Se il course service dipende da IAuthorizationService // ...e viceversa l'authorization handler dipende dal course service, allora la dependency injection non riuscirà a risolvere nessuno dei due servizi, dandoci un errore AuthorizationResult result = await authorizationService.AuthorizeAsync(User, nameof(Policy.CourseLimit)); if (!result.Succeeded) { await emailClient.SendEmailAsync(usersOptions.CurrentValue.NotificationEmailRecipient, "Avviso superamento soglia", $"Il docente {User.Identity.Name} ha creato molti corsi: verifica che riesca a gestirli tutti."); } TempData["ConfirmationMessage"] = "Ok! Il tuo corso è stato creato, ora perché non inserisci anche gli altri dati?"; return(RedirectToAction(nameof(Edit), new { id = course.Id })); } catch (CourseTitleUnavailableException) { ModelState.AddModelError(nameof(CourseDetailViewModel.Title), "Questo titolo già esiste"); } } ViewData["Title"] = "Nuovo corso"; return(View(inputModel)); }
public SystemTokenAuthenticationHandler(IOptionsMonitor <Opts> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock, IDatabase db) : base(options, logger, encoder, clock) { _db = db; }
/// <summary> /// /// </summary> /// <param name="options"></param> /// <param name="logger"></param> public SmtpClientService(IOptionsMonitor <EmailStmpOption> options, ILogger <SmtpClientService> logger) { emailConfig = options.CurrentValue.EmailSetting; _logger = logger; }
public TwitterHandler2(IOptionsMonitor <TwitterOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock) { }
public AttachmentService(IAttachmentRepository repository, IAttachmentOwnerRepository ownerRepository, IOptionsMonitor <ModuleCommonOptions> moduleCommonOptionsMonitor, IMediaTypeRepository mediaTypeRepository, IMapper mapper, CommonDbContext dbContext) { _repository = repository; _ownerRepository = ownerRepository; _moduleCommonOptions = moduleCommonOptionsMonitor.CurrentValue; _mediaTypeRepository = mediaTypeRepository; _mapper = mapper; _dbContext = dbContext; }
public BalanceNoteRepository(IOptionsMonitor <DbSettings> options) : base(options) { }
public HeaderAuthenticationHandler(IOptionsMonitor <HeaderAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock) { }
public ConsoleLoggerProvider(IOptionsMonitor <BatchingLoggerOptions> options) : base(options) { }
public ApiKeyAuthenticationHandler(IOptionsMonitor <ApiKeyAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock, IServiceProvider serviceProvider) : base(options, logger, encoder, clock) { ServiceProvider = serviceProvider; }
public IndexModel(IAccountContext account, IOptionsMonitor <AppConfig> appConfig) : base(appConfig) { _account = account; }
public CountryApiClient(HttpClient client, IOptionsMonitor <AppSettingsOptions> appSettings) { _client = client ?? throw new ArgumentNullException(nameof(client)); _appSettings = appSettings ?? throw new ArgumentNullException(nameof(appSettings)); }
public FileVersionScrubService(IServiceScopeFactory serviceScopeFactory, IOptionsMonitor <FileVersionScrubOptions> fileVersionScrubOptions, ILogger <FileVersionScrubService> logger) { _serviceScopeFactory = serviceScopeFactory; _fileVersionScrubOptions = fileVersionScrubOptions; _logger = logger; }
public TenantStatusFilter(IOptionsMonitor <ILog> options, TenantManager tenantManager) { log = options.CurrentValue; TenantManager = tenantManager; }
public HelloService(IHttpMessageHandlerFactory factory, ILogger <HelloService> logger, IOptionsMonitor <HelloServiceOptions> options) { _logger = logger; _client = new Hello_PortTypeClient(); _client.Endpoint.EndpointBehaviors.Add(new HttpMessageHandlerBehavior(factory, ServiceName)); _client.Endpoint.Address = new EndpointAddress(options.CurrentValue.EndpointAddress); _client.Endpoint.Binding.CloseTimeout = TimeSpan.FromSeconds(options.CurrentValue.TimeoutSeconds); _client.Endpoint.Binding.OpenTimeout = TimeSpan.FromSeconds(options.CurrentValue.TimeoutSeconds); _client.Endpoint.Binding.ReceiveTimeout = TimeSpan.FromSeconds(options.CurrentValue.TimeoutSeconds); _client.Endpoint.Binding.SendTimeout = TimeSpan.FromSeconds(options.CurrentValue.TimeoutSeconds); }
public UsersController(IAddRepresentationCommandHandler addRepresentationCommandHandler, IDeleteRepresentationCommandHandler deleteRepresentationCommandHandler, IReplaceRepresentationCommandHandler replaceRepresentationCommandHandler, IPatchRepresentationCommandHandler patchRepresentationCommandHandler, ISCIMRepresentationQueryRepository scimRepresentationQueryRepository, ISCIMSchemaQueryRepository scimSchemaQueryRepository, IAttributeReferenceEnricher attributeReferenceEnricher, IOptionsMonitor <SCIMHostOptions> options, ILogger <UsersController> logger) : base(SCIMConstants.SCIMEndpoints.User, addRepresentationCommandHandler, deleteRepresentationCommandHandler, replaceRepresentationCommandHandler, patchRepresentationCommandHandler, scimRepresentationQueryRepository, scimSchemaQueryRepository, attributeReferenceEnricher, options, logger) { }
public void EmptyCtor_Should_ThrowException( IOptionsMonitor <AppSettings> settings) { Assert.Throws <ArgumentNullException>(() => new EventCanceledIntegrationEventHandler(null, settings)); }
public BasicAuthenticationHandler(IOptionsMonitor <AuthenticationSchemeOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock) { }
public TwilioSignatureValidator(IOptionsMonitor <TwilioSettings> settingsMonitor) { _settingsMonitor = settingsMonitor; }
/// <summary> /// Initializes a new instance of the <see cref="LinkTagHelper"/> class. /// </summary> public LinkTagHelper(IWebHostEnvironment env, IMemoryCache cache, IAssetPipeline pipeline, IOptionsMonitor <WebOptimizerOptions> options) : base(env, cache, pipeline, options) { }