IOptions

IOptionsSnapshot.cs (1)

13IOptions<TOptions>

DefaultAntiforgeryTest.cs (1)

1569private class TestOptionsManager : IOptions<AntiforgeryOptions>

TestOptionsManager.cs (1)

8public class TestOptionsManager : IOptions<AntiforgeryOptions>

PasswordHasherTest.cs (1)

205private class PasswordHasherOptionsAccessor : IOptions<PasswordHasherOptions>

ModelBinding\ModelStateDictionaryTest.cs (1)

1761private class OptionsAccessor : IOptions<MvcOptions>

ModelBinding\EmptyModelMetadataProvider.cs (1)

26private sealed class OptionsAccessor : IOptions<MvcOptions>

TestMvcOptions.cs (1)

15public class TestMvcOptions : IOptions<MvcOptions>

BrotliCompressionProviderOptions.cs (1)

12public class BrotliCompressionProviderOptions : IOptions<BrotliCompressionProviderOptions>

GzipCompressionProviderOptions.cs (1)

12public class GzipCompressionProviderOptions : IOptions<GzipCompressionProviderOptions>

MemoryCacheOptions.cs (1)

14public class MemoryCacheOptions : IOptions<MemoryCacheOptions>

SqlServerCacheOptions.cs (1)

13public class SqlServerCacheOptions : IOptions<SqlServerCacheOptions>

TestOptions.cs (1)

8internal class TestSqlServerCacheOptions : IOptions<SqlServerCacheOptions>

RedisCacheOptions.cs (1)

16public class RedisCacheOptions : IOptions<RedisCacheOptions>

OptionsManager.cs (1)

14IOptions<TOptions>,

OptionsWrapper.cs (1)

13IOptions<TOptions>

UnnamedOptionsManager.cs (1)

10IOptions<TOptions>

Controllers\ContentNegotiation\FallbackOnTypeBasedMatchController.cs (3)

13private readonly IOptions<MvcOptions> _mvcOptions; 16public FallbackOnTypeBasedMatchController(IOptions<MvcOptions> mvcOptions) 73[FromServices] IOptions<MvcOptions> optionsAccessor)

Program.cs (2)

37var hostFilteringOptions = app.ApplicationServices.GetRequiredService<IOptions<HostFilteringOptions>>();

Authorization\MinimumAgePolicyProvider.cs (1)

16public MinimumAgePolicyProvider(IOptions<AuthorizationOptions> options)

src\Shared\Http2cat\Http2CatHostedService.cs (1)

32IOptions<Http2CatOptions> options, IHostApplicationLifetime hostApplicationLifetime)

src\Shared\Http2cat\Http2CatHostedService.cs (1)

32IOptions<Http2CatOptions> options, IHostApplicationLifetime hostApplicationLifetime)

src\Shared\Http2cat\Http2CatHostedService.cs (1)

32IOptions<Http2CatOptions> options, IHostApplicationLifetime hostApplicationLifetime)

src\Shared\Http2cat\Http2CatHostedService.cs (1)

32IOptions<Http2CatOptions> options, IHostApplicationLifetime hostApplicationLifetime)

src\Shared\Http2cat\Http2CatHostedService.cs (1)

32IOptions<Http2CatOptions> options, IHostApplicationLifetime hostApplicationLifetime)

src\Shared\Http2cat\Http2CatHostedService.cs (1)

32IOptions<Http2CatOptions> options, IHostApplicationLifetime hostApplicationLifetime)

Program.cs (1)

347var keyManagementOptions = Options.Create(new KeyManagementOptions()

Internal\AntiforgeryOptionsSetup.cs (1)

16public AntiforgeryOptionsSetup(IOptions<DataProtectionOptions> dataProtectionOptions)

Internal\DefaultAntiforgery.cs (1)

26IOptions<AntiforgeryOptions> antiforgeryOptionsAccessor,

Internal\DefaultAntiforgeryTokenStore.cs (1)

15public DefaultAntiforgeryTokenStore(IOptions<AntiforgeryOptions> optionsAccessor)

AntiforgeryOptionsSetupTest.cs (4)

28var options = services.GetRequiredService<IOptions<AntiforgeryOptions>>(); 53var options = services.GetRequiredService<IOptions<AntiforgeryOptions>>();

AuthenticationBuilder.cs (1)

117public EnsureSignInScheme(IOptions<AuthenticationOptions> authOptions)

BearerTokenHandler.cs (1)

86var typeInfo = httpContext.RequestServices.GetService<IOptions<JsonOptions>>()

CertificateValidationCache.cs (2)

21internal CertificateValidationCache(IOptions<CertificateValidationCacheOptions> options, TimeProvider timeProvider) 32public CertificateValidationCache(IOptions<CertificateValidationCacheOptions> options) : this(options, TimeProvider.System)

AuthenticationSchemeProvider.cs (2)

20public AuthenticationSchemeProvider(IOptions<AuthenticationOptions> options) 31protected AuthenticationSchemeProvider(IOptions<AuthenticationOptions> options, IDictionary<string, AuthenticationScheme> schemes)

AuthenticationService.cs (1)

25public AuthenticationService(IAuthenticationSchemeProvider schemes, IAuthenticationHandlerProvider handlers, IClaimsTransformation transform, IOptions<AuthenticationOptions> options)

AuthenticationSchemeProviderTests.cs (1)

302public IgnoreCaseSchemeProvider(IOptions<AuthenticationOptions> options)

ServerDeferralTests.cs (2)

20var options = host.Services.GetRequiredService<IOptions<NegotiateOptions>>().Value; 37var options = host.Services.GetRequiredService<IOptions<NegotiateOptions>>().Value;

DefaultAuthorizationPolicyProvider.cs (1)

25public DefaultAuthorizationPolicyProvider(IOptions<AuthorizationOptions> options)

DefaultAuthorizationService.cs (1)

35public DefaultAuthorizationService(IAuthorizationPolicyProvider policyProvider, IAuthorizationHandlerProvider handlers, ILogger<DefaultAuthorizationService> logger, IAuthorizationHandlerContextFactory contextFactory, IAuthorizationEvaluator evaluator, IOptions<AuthorizationOptions> options)

PassThroughAuthorizationHandler.cs (1)

28public PassThroughAuthorizationHandler(IOptions<AuthorizationOptions> options)

AuthorizationBuilderTests.cs (6)

21var options = builder.Services.BuildServiceProvider().GetRequiredService<IOptions<AuthorizationOptions>>().Value; 37var options = builder.Services.BuildServiceProvider().GetRequiredService<IOptions<AuthorizationOptions>>().Value; 52var options = builder.Services.BuildServiceProvider().GetRequiredService<IOptions<AuthorizationOptions>>().Value; 68var options = builder.Services.BuildServiceProvider().GetRequiredService<IOptions<AuthorizationOptions>>().Value; 83var options = builder.Services.BuildServiceProvider().GetRequiredService<IOptions<AuthorizationOptions>>().Value; 97var options = builder.Services.BuildServiceProvider().GetRequiredService<IOptions<AuthorizationOptions>>().Value;

AuthorizationMiddlewareTests.cs (1)

330public TestDefaultPolicyProvider(IOptions<AuthorizationOptions> options, bool canCache) : base(options)

Routing\RouteTableFactory.cs (1)

118var routeOptions = Options.Create(new RouteOptions());

src\Http\Routing\src\DefaultInlineConstraintResolver.cs (1)

31public DefaultInlineConstraintResolver(IOptions<RouteOptions> routeOptions, IServiceProvider serviceProvider)

Builder\OpaqueRedirection.cs (2)

44var options = httpContext.RequestServices.GetRequiredService<IOptions<RazorComponentsServiceOptions>>();

FormMapping\HttpContextFormValueMapper.cs (1)

25IOptions<RazorComponentsServiceOptions> options)

Rendering\EndpointHtmlRenderer.cs (1)

55_options = serviceProvider.GetRequiredService<IOptions<RazorComponentsServiceOptions>>().Value;

Rendering\EndpointHtmlRenderer.Streaming.cs (2)

200var options = httpContext.RequestServices.GetRequiredService<IOptions<RazorComponentsServiceOptions>>();

CircuitJavaScriptInitializationMiddleware.cs (1)

16public CircuitJavaScriptInitializationMiddleware(IOptions<CircuitOptions> options, RequestDelegate _)

Circuits\CircuitFactory.cs (1)

27IOptions<CircuitOptions> options)

Circuits\CircuitRegistry.cs (1)

47IOptions<CircuitOptions> options,

Circuits\RemoteErrorBoundaryLogger.cs (1)

17public RemoteErrorBoundaryLogger(ILogger<ErrorBoundary> logger, IJSRuntime jsRuntime, IOptions<CircuitOptions> options)

Circuits\RemoteJSRuntime.cs (2)

41IOptions<CircuitOptions> circuitOptions, 42IOptions<HubOptions<ComponentHub>> componentHubOptions,

Circuits\ComponentHubTest.cs (1)

186IOptions<CircuitOptions> options)

Circuits\RemoteJSDataStreamTest.cs (2)

302public TestRemoteJSRuntime(IOptions<CircuitOptions> circuitOptions, IOptions<HubOptions<ComponentHub>> hubOptions, ILogger<RemoteJSRuntime> logger) : base(circuitOptions, hubOptions, logger)

Circuits\RemoteJSRuntimeTest.cs (3)

102var componentHubOptions = Options.Create(new HubOptions<ComponentHub>()); 110public TestRemoteJSRuntime(IOptions<CircuitOptions> circuitOptions, IOptions<HubOptions<ComponentHub>> hubOptions, ILogger<RemoteJSRuntime> logger) : base(circuitOptions, hubOptions, logger)

DependencyInjection\ComponentServiceCollectionExtensionsTest.cs (8)

21var options = services.BuildServiceProvider().GetRequiredService<IOptions<HubOptions<ComponentHub>>>(); 42var options = services.BuildServiceProvider().GetRequiredService<IOptions<HubOptions<ComponentHub>>>(); 68var options = services.BuildServiceProvider().GetRequiredService<IOptions<HubOptions<ComponentHub>>>(); 69var globalOptions = services.BuildServiceProvider().GetRequiredService<IOptions<HubOptions>>();

AuthenticationStateSerializer.cs (1)

21public AuthenticationStateSerializer(PersistentComponentState persistentComponentState, IOptions<AuthenticationStateSerializationOptions> options)

ConcurrencyLimiterMiddleware.cs (1)

28public ConcurrencyLimiterMiddleware(RequestDelegate next, ILoggerFactory loggerFactory, IQueuePolicy queue, IOptions<ConcurrencyLimiterOptions> options)

QueuePolicies\BasePolicy.cs (1)

19public BasePolicy(IOptions<QueuePolicyOptions> options, QueueProcessingOrder order)

QueuePolicies\QueuePolicy.cs (1)

11public QueuePolicy(IOptions<QueuePolicyOptions> options)

QueuePolicies\StackPolicy.cs (1)

11public StackPolicy(IOptions<QueuePolicyOptions> options)

TestUtils.cs (3)

15var options = Options.Create(new ConcurrencyLimiterOptions 48var options = Options.Create(new QueuePolicyOptions 59var options = Options.Create(new QueuePolicyOptions

CookiePolicyMiddleware.cs (2)

35public CookiePolicyMiddleware(RequestDelegate next, IOptions<CookiePolicyOptions> options, ILoggerFactory factory) 47public CookiePolicyMiddleware(RequestDelegate next, IOptions<CookiePolicyOptions> options)

Infrastructure\CorsService.cs (1)

27public CorsService(IOptions<CorsOptions> options, ILoggerFactory loggerFactory)

Infrastructure\DefaultCorsPolicyProvider.cs (1)

19public DefaultCorsPolicyProvider(IOptions<CorsOptions> options)

DefaultCorsPolicyProviderTests.cs (2)

19var corsOptions = Options.Create(options); 39var corsOptions = Options.Create(options);

DataProtectionServiceCollectionExtensions.cs (2)

85var dpOptions = s.GetRequiredService<IOptions<DataProtectionOptions>>();

KeyManagement\DefaultKeyResolver.cs (2)

56public DefaultKeyResolver(IOptions<KeyManagementOptions> keyManagementOptions) 60public DefaultKeyResolver(IOptions<KeyManagementOptions> keyManagementOptions, ILoggerFactory loggerFactory)

KeyManagement\KeyRingProvider.cs (2)

34IOptions<KeyManagementOptions> keyManagementOptions, 46IOptions<KeyManagementOptions> keyManagementOptions,

KeyManagement\XmlKeyManager.cs (6)

68/// <param name="keyManagementOptions">The <see cref="IOptions{KeyManagementOptions}"/> instance that provides the configuration.</param> 71public XmlKeyManager(IOptions<KeyManagementOptions> keyManagementOptions, IActivator activator) 79/// <param name="keyManagementOptions">The <see cref="IOptions{KeyManagementOptions}"/> instance that provides the configuration.</param> 83public XmlKeyManager(IOptions<KeyManagementOptions> keyManagementOptions, IActivator activator, ILoggerFactory loggerFactory) 89IOptions<KeyManagementOptions> keyManagementOptions, 127IOptions<KeyManagementOptions> keyManagementOptions,

XmlEncryption\EncryptedXmlDecryptor.cs (1)

40_options = services?.GetService<IOptions<XmlKeyDecryptionOptions>>()?.Value;

DataProtectionProviderTests.cs (1)

63s.GetRequiredService<IOptions<KeyManagementOptions>>(),

KeyManagement\DefaultKeyResolverTests.cs (2)

336var options = Options.Create(new KeyManagementOptions() 413var options = Options.Create(new KeyManagementOptions()

KeyManagement\XmlKeyManagerTests.cs (11)

ServiceCollectionTests.cs (3)

26Assert.NotNull(services.GetService<IOptions<DataProtectionOptions>>()); 88var options = services.GetRequiredService<IOptions<KeyManagementOptions>>().Value; 121var options = services.GetRequiredService<IOptions<KeyManagementOptions>>().Value;

DeveloperExceptionPage\DeveloperExceptionPageMiddleware.cs (1)

31IOptions<DeveloperExceptionPageOptions> options,

DeveloperExceptionPage\DeveloperExceptionPageMiddlewareImpl.cs (2)

47IOptions<DeveloperExceptionPageOptions> options, 53IOptions<JsonOptions>? jsonOptions = null,

ExceptionHandler\ExceptionHandlerExtensions.cs (3)

103var iOptions = Options.Create(options); 107private static IApplicationBuilder SetExceptionHandlerMiddleware(IApplicationBuilder app, IOptions<ExceptionHandlerOptions>? options) 125options = app.ApplicationServices.GetRequiredService<IOptions<ExceptionHandlerOptions>>();

ExceptionHandler\ExceptionHandlerMiddleware.cs (1)

30IOptions<ExceptionHandlerOptions> options,

ExceptionHandler\ExceptionHandlerMiddlewareImpl.cs (1)

36IOptions<ExceptionHandlerOptions> options,

StatusCodePage\StatusCodePagesMiddleware.cs (1)

24public StatusCodePagesMiddleware(RequestDelegate next, IOptions<StatusCodePagesOptions> options)

WelcomePage\WelcomePageMiddleware.cs (1)

24public WelcomePageMiddleware(RequestDelegate next, IOptions<WelcomePageOptions> options)

DatabaseDeveloperPageExceptionFilter.cs (2)

34/// <param name="options">The <see cref="IOptions{DatabaseErrorPageOptions}"/>.</param> 35public DatabaseDeveloperPageExceptionFilter(ILogger<DatabaseDeveloperPageExceptionFilter> logger, IOptions<DatabaseErrorPageOptions> options)

DatabaseErrorPageMiddleware.cs (1)

55IOptions<DatabaseErrorPageOptions> options)

MigrationsEndPointMiddleware.cs (1)

34IOptions<MigrationsEndPointOptions> options)

Builder\HealthCheckApplicationBuilderExtensions.cs (3)

31/// The health check middleware will use default settings from <see cref="IOptions{HealthCheckOptions}"/>. 82/// The health check middleware will use default settings from <see cref="IOptions{HealthCheckOptions}"/>. 109/// The health check middleware will use default settings from <see cref="IOptions{HealthCheckOptions}"/>.

HealthCheckMiddleware.cs (1)

24IOptions<HealthCheckOptions> healthCheckOptions,

ExceptionHandlerMiddlewareTest.cs (14)

Internal\Binding\JsonTranscodingServiceMethodProvider.cs (3)

26IOptions<GrpcServiceOptions> globalOptions, 27IOptions<GrpcServiceOptions<TService>> serviceOptions, 29IOptions<GrpcJsonTranscodingOptions> jsonTranscodingOptions,

Infrastructure\DynamicGrpcServiceRegistry.cs (3)

145var JsonTranscodingOptions = _serviceProvider.GetRequiredService<IOptions<GrpcJsonTranscodingOptions>>().Value; 150_serviceProvider.GetRequiredService<IOptions<GrpcServiceOptions>>().Value, 151_serviceProvider.GetRequiredService<IOptions<GrpcServiceOptions<DynamicService>>>().Value,

GrpcJsonTranscodingServiceExtensionsTests.cs (3)

22var options1 = serviceProvider.GetRequiredService<IOptions<GrpcJsonTranscodingOptions>>().Value; 26var options2 = serviceProvider.GetRequiredService<IOptions<GrpcJsonTranscodingOptions>>().Value; 47var options = serviceProvider.GetRequiredService<IOptions<GrpcJsonTranscodingOptions>>().Value;

GrpcSwaggerServiceExtensions.cs (1)

50var serializerOptions = s.GetService<IOptions<JsonOptions>>()?.Value?.JsonSerializerOptions ?? new JsonSerializerOptions();

DependencyInjection\HeaderPropagationHttpClientBuilderExtensions.cs (2)

31var middlewareOptions = services.GetRequiredService<IOptions<HeaderPropagationOptions>>();

HeaderPropagationMiddleware.cs (2)

24/// <param name="options">The <see cref="IOptions{HeaderPropagationOptions}"/>.</param> 28public HeaderPropagationMiddleware(RequestDelegate next, IOptions<HeaderPropagationOptions> options, HeaderPropagationValues values)

GenericHost\GenericWebHostService.cs (1)

19public GenericWebHostService(IOptions<GenericWebHostServiceOptions> options,

Http\DefaultHttpContextFactory.cs (1)

33_formOptions = serviceProvider.GetRequiredService<IOptions<FormOptions>>().Value;

StartupManagerTests.cs (2)

353var options = app.ApplicationServices.GetRequiredService<IOptions<FakeOptions>>().Value; 400var options = app.ApplicationServices.GetRequiredService<IOptions<FakeOptions>>().Value;

WebHostTests.cs (1)

742Assert.NotNull(host.Services.GetRequiredService<IOptions<object>>());

Internal\HttpConnectionManager.cs (1)

30public HttpConnectionManager(ILoggerFactory loggerFactory, IHostApplicationLifetime appLifetime, IOptions<ConnectionOptions> connectionOptions, HttpConnectionsMetrics metrics)

HttpConnectionFactory.cs (1)

28public HttpConnectionFactory(IOptions<HttpConnectionOptions> options, ILoggerFactory loggerFactory)

DefaultProblemDetailsWriter.cs (2)

20public DefaultProblemDetailsWriter(IOptions<ProblemDetailsOptions> options, IOptions<JsonOptions> jsonOptions)

HttpRequestJsonExtensions.cs (1)

306return httpContext.RequestServices?.GetService<IOptions<JsonOptions>>()?.Value?.SerializerOptions ?? JsonOptions.DefaultSerializerOptions;

HttpResponseJsonExtensions.cs (1)

340return httpContext.RequestServices?.GetService<IOptions<JsonOptions>>()?.Value?.SerializerOptions ?? JsonOptions.DefaultSerializerOptions;

RequestDelegateFactory.cs (1)

278var jsonSerializerOptions = serviceProvider.GetService<IOptions<JsonOptions>>()?.Value.SerializerOptions ?? JsonOptions.DefaultSerializerOptions;

ProblemDetailsServiceCollectionExtensionsTest.cs (12)

98var jsonOptions = services.GetService<IOptions<JsonOptions>>(); 123var jsonOptions = services.GetService<IOptions<JsonOptions>>(); 163var jsonOptions = services.GetService<IOptions<JsonOptions>>(); 184var jsonOptions = services.GetService<IOptions<JsonOptions>>(); 204var jsonOptions = services.GetService<IOptions<JsonOptions>>(); 229var jsonOptions = services.GetService<IOptions<JsonOptions>>();

RequestDelegateFactoryTests.cs (1)

864if (t == typeof(IOptions<JsonOptions>))

RequestDelegateGenerator\RequestDelegateCreationTests.BindAsync.cs (2)

225if (t == typeof(IOptions<JsonOptions>)) 281if (t == typeof(IOptions<JsonOptions>))

HttpResultsHelper.cs (1)

154return httpContext.RequestServices.GetService<IOptions<JsonOptions>>()?.Value ?? new JsonOptions();

CertificateForwardingMiddleware.cs (1)

30IOptions<CertificateForwardingOptions> options)

ForwardedHeadersMiddleware.cs (1)

46public ForwardedHeadersMiddleware(RequestDelegate next, ILoggerFactory loggerFactory, IOptions<ForwardedHeadersOptions> options)

HttpMethodOverrideMiddleware.cs (1)

24public HttpMethodOverrideMiddleware(RequestDelegate next, IOptions<HttpMethodOverrideOptions> options)

CertificateForwardingTest.cs (4)

23var options = services.BuildServiceProvider().GetRequiredService<IOptions<CertificateForwardingOptions>>(); 33var options = services.BuildServiceProvider().GetRequiredService<IOptions<CertificateForwardingOptions>>();

HstsMiddleware.cs (2)

33public HstsMiddleware(RequestDelegate next, IOptions<HstsOptions> options, ILoggerFactory loggerFactory) 54public HstsMiddleware(RequestDelegate next, IOptions<HstsOptions> options)

HttpsRedirectionMiddleware.cs (2)

36public HttpsRedirectionMiddleware(RequestDelegate next, IOptions<HttpsRedirectionOptions> options, IConfiguration config, ILoggerFactory loggerFactory) 66public HttpsRedirectionMiddleware(RequestDelegate next, IOptions<HttpsRedirectionOptions> options, IConfiguration config, ILoggerFactory loggerFactory,

AspNetUserManager.cs (1)

32IOptions<IdentityOptions> optionsAccessor,

DataProtectorTokenProvider.cs (1)

25IOptions<DataProtectionTokenProviderOptions> options,

SecurityStampValidator.cs (2)

27public SecurityStampValidator(IOptions<SecurityStampValidatorOptions> options, SignInManager<TUser> signInManager, ISystemClock clock, ILoggerFactory logger) 44public SecurityStampValidator(IOptions<SecurityStampValidatorOptions> options, SignInManager<TUser> signInManager, ILoggerFactory logger)

SignInManager.cs (1)

43IOptions<IdentityOptions> optionsAccessor,

TwoFactorSecurityStampValidator.cs (2)

26public TwoFactorSecurityStampValidator(IOptions<SecurityStampValidatorOptions> options, SignInManager<TUser> signInManager, ISystemClock clock, ILoggerFactory logger) : base(options, signInManager, clock, logger) 35public TwoFactorSecurityStampValidator(IOptions<SecurityStampValidatorOptions> options, SignInManager<TUser> signInManager, ILoggerFactory logger) : base(options, signInManager, logger)

IdentityUserContext.cs (1)

106?.GetService<IOptions<IdentityOptions>>()

src\Identity\test\Shared\MockHelpers.cs (1)

36var options = new Mock<IOptions<IdentityOptions>>();

src\Identity\test\Shared\MockHelpers.cs (1)

36var options = new Mock<IOptions<IdentityOptions>>();

IdentityBuilderTest.cs (4)

215Assert.NotNull(provider.GetService<IOptions<SecurityStampValidatorOptions>>()); 235Assert.NotNull(provider.GetService<IOptions<SecurityStampValidatorOptions>>()); 246var tokenProviders = provider.GetRequiredService<IOptions<IdentityOptions>>().Value.Tokens.ProviderMap.Values; 406public MyClaimsPrincipalFactory(UserManager<PocoUser> userManager, RoleManager<PocoRole> roleManager, IOptions<IdentityOptions> optionsAccessor) : base(userManager, roleManager, optionsAccessor)

IdentityOptionsTest.cs (4)

46var optionsGetter = serviceProvider.GetRequiredService<IOptions<IdentityOptions>>(); 64var optionsGetter = serviceProvider.GetRequiredService<IOptions<IdentityOptions>>();

PasswordHasherTest.cs (1)

175private static IOptions<PasswordHasherOptions> BuildOptions(PasswordHasherCompatibilityMode? compatMode, int? iterCount)

SecurityStampValidatorTest.cs (12)

SignInManagerTest.cs (7)

44var options = new Mock<IOptions<IdentityOptions>>(); 74var options = new Mock<IOptions<IdentityOptions>>(); 106var options = new Mock<IOptions<IdentityOptions>>(); 1284var options = Options.Create(new IdentityOptions()); 1303IOptions<IdentityOptions> optionsAccessor) 1315IOptions<IdentityOptions> optionsAccessor) 1332IOptions<IdentityOptions> optionsAccessor)

src\Identity\test\Shared\MockHelpers.cs (1)

36var options = new Mock<IOptions<IdentityOptions>>();

UserClaimsPrincipalFactoryTest.cs (2)

17var options = new Mock<IOptions<IdentityOptions>>(); 80var options = new Mock<IOptions<IdentityOptions>>();

RequestLocalizationMiddleware.cs (1)

33public RequestLocalizationMiddleware(RequestDelegate next, IOptions<RequestLocalizationOptions> options, ILoggerFactory loggerFactory)

DefaultApiDescriptionProvider.cs (2)

42IOptions<MvcOptions> optionsAccessor, 46IOptions<RouteOptions> routeOptions)

DefaultApiDescriptionProviderTest.cs (1)

2236var optionsAccessor = Options.Create(options);

EndpointMetadataApiDescriptionProviderTest.cs (1)

1507if (serviceType == typeof(IOptions<RouteHandlerOptions>))

ApplicationModels\ApiBehaviorApplicationModelProvider.cs (1)

17IOptions<ApiBehaviorOptions> apiBehaviorOptions,

ApplicationModels\ApplicationModelFactory.cs (1)

24IOptions<MvcOptions> options)

ApplicationModels\AuthorizationApplicationModelProvider.cs (1)

18IOptions<MvcOptions> mvcOptions)

ApplicationModels\DefaultApplicationModelProvider.cs (1)

28IOptions<MvcOptions> mvcOptionsAccessor,

Builder\MvcApplicationBuilderExtensions.cs (2)

68var options = app.ApplicationServices.GetRequiredService<IOptions<MvcOptions>>();

DependencyInjection\MvcCoreServiceCollectionExtensions.cs (2)

211var options = s.GetRequiredService<IOptions<MvcOptions>>().Value; 217var options = s.GetRequiredService<IOptions<MvcOptions>>().Value;

Formatters\FormatFilter.cs (2)

25/// <param name="options">The <see cref="IOptions{MvcOptions}"/></param> 27public FormatFilter(IOptions<MvcOptions> options, ILoggerFactory loggerFactory)

Infrastructure\CompatibilitySwitch.cs (1)

50/// implementation of <see cref="ICompatibilitySwitch"/> suitable for use with the <see cref="IOptions{T}"/>

Infrastructure\ConfigureCompatibilityOptions.cs (2)

27/// <param name="compatibilityOptions">The <see cref="IOptions{MvcCompatibilityOptions}"/>.</param> 30IOptions<MvcCompatibilityOptions> compatibilityOptions)

Infrastructure\ControllerActionInvokerCache.cs (1)

30IOptions<MvcOptions> mvcOptions)

Infrastructure\ControllerActionInvokerProvider.cs (2)

30IOptions<MvcOptions> optionsAccessor, 40IOptions<MvcOptions> optionsAccessor,

Infrastructure\DefaultApiProblemDetailsWriter.cs (1)

27IOptions<ApiBehaviorOptions> apiBehaviorOptions)

Infrastructure\DefaultOutputFormatterSelector.cs (1)

37public DefaultOutputFormatterSelector(IOptions<MvcOptions> options, ILoggerFactory loggerFactory)

Infrastructure\DefaultProblemDetailsFactory.cs (2)

29IOptions<ApiBehaviorOptions> options, 30IOptions<ProblemDetailsOptions>? problemDetailsOptions = null)

Infrastructure\ModelStateInvalidFilterFactory.cs (2)

21var options = serviceProvider.GetRequiredService<IOptions<ApiBehaviorOptions>>();

Infrastructure\MvcCoreMvcOptionsSetup.cs (2)

27private readonly IOptions<JsonOptions> _jsonOptions; 34public MvcCoreMvcOptionsSetup(IHttpRequestStreamReaderFactory readerFactory, ILoggerFactory loggerFactory, IOptions<JsonOptions> jsonOptions)

Infrastructure\ObjectResultExecutor.cs (1)

31IOptions<MvcOptions> mvcOptions)

Infrastructure\SystemTextJsonResultExecutor.cs (1)

27IOptions<JsonOptions> options,

ModelBinding\Binders\ArrayModelBinderProvider.cs (1)

29var mvcOptions = context.Services.GetRequiredService<IOptions<MvcOptions>>().Value;

ModelBinding\Binders\CollectionModelBinderProvider.cs (1)

61var mvcOptions = context.Services.GetRequiredService<IOptions<MvcOptions>>().Value;

ModelBinding\Binders\DictionaryModelBinderProvider.cs (1)

36var mvcOptions = context.Services.GetRequiredService<IOptions<MvcOptions>>().Value;

ModelBinding\DefaultModelBindingContext.cs (2)

235var mvcOptions = actionContext.HttpContext.RequestServices?.GetService<IOptions<MvcOptions>>();

ModelBinding\Metadata\DefaultModelMetadataProvider.cs (2)

40IOptions<MvcOptions> optionsAccessor) 143private static DefaultModelBindingMessageProvider GetMessageProvider(IOptions<MvcOptions> optionsAccessor)

ModelBinding\ModelBinderFactory.cs (2)

33/// <param name="options">The <see cref="IOptions{TOptions}"/> for <see cref="MvcOptions"/>.</param> 37IOptions<MvcOptions> options,

ModelBinding\ParameterBinder.cs (1)

34IOptions<MvcOptions> mvcOptions,

RequireHttpsAttribute.cs (2)

72var optionsAccessor = filterContext.HttpContext.RequestServices.GetRequiredService<IOptions<MvcOptions>>();

ResponseCacheAttribute.cs (2)

123var optionsAccessor = serviceProvider.GetRequiredService<IOptions<MvcOptions>>();

Routing\ControllerRequestDelegateFactory.cs (2)

32IOptions<MvcOptions> optionsAccessor, 42IOptions<MvcOptions> optionsAccessor,

AcceptedAtActionResultTests.cs (1)

268var options = Options.Create(new MvcOptions());

AcceptedAtRouteResultTests.cs (1)

176var options = Options.Create(new MvcOptions());

AcceptedResultTests.cs (1)

133var options = Options.Create(new MvcOptions());

ApplicationModels\ApiBehaviorApplicationModelProviderTest.cs (1)

216var optionsAccessor = Options.Create(options);

ApplicationModels\AuthorizationApplicationModelProviderTest.cs (3)

16private readonly IOptions<MvcOptions> OptionsWithoutEndpointRouting = Options.Create(new MvcOptions { EnableEndpointRouting = false }); 76var options = Options.Create(new AuthorizationOptions()); 130var authOptions = Options.Create(new AuthorizationOptions());

ApplicationModels\ConsumesConstraintForFormFileParameterConventionTest.cs (1)

61var mvcOptions = Options.Create(new MvcOptions());

ApplicationModels\ControllerActionDescriptorProviderTests.cs (5)

696var options = Options.Create(new MvcOptions()); 1150var options = Options.Create(new MvcOptions()); 1328var options = Options.Create(new MvcOptions()); 1351var options = Options.Create(new MvcOptions()); 1367var options = Options.Create(new MvcOptions());

ApplicationModels\EndpointMetadataProviderTest.cs (1)

242var options = Options.Create(new MvcOptions());

ApplicationModels\InferParameterBindingInfoConventionTest.cs (1)

913var mvcOptions = Options.Create(new MvcOptions());

Controllers\ControllerBinderDelegateProviderTest.cs (1)

26private static readonly IOptions<MvcOptions> _optionsAccessor = Options.Create(_options);

CreatedAtActionResultTests.cs (1)

86var options = Options.Create(new MvcOptions());

CreatedAtRouteResultTests.cs (1)

100var options = Options.Create(new MvcOptions());

CreatedResultTests.cs (1)

133var options = Options.Create(new MvcOptions());

DependencyInjection\MvcBuilderExtensionsTest.cs (1)

155.GetRequiredService<IOptions<ApiBehaviorOptions>>()

DependencyInjection\MvcCoreBuilderExtensionsTest.cs (1)

98.GetRequiredService<IOptions<ApiBehaviorOptions>>()

Filters\MiddlewareFilterTest.cs (1)

265var optionsAccessor = new Mock<IOptions<MvcOptions>>();

Formatters\FormatFilterTest.cs (1)

396public IOptions<MvcOptions> OptionsManager { get; private set; }

HttpNotFoundObjectResultTest.cs (1)

66var options = Options.Create(new MvcOptions());

HttpOkObjectResultTest.cs (1)

68var options = Options.Create(new MvcOptions());

Infrastructure\ActionSelectorTest.cs (1)

1002var options = Options.Create(new MvcOptions());

Infrastructure\ConfigureCompatibilityOptionsTest.cs (2)

77var compatibilityOptions = Options.Create(new MvcCompatibilityOptions() { CompatibilityVersion = version }); 111IOptions<MvcCompatibilityOptions> compatibilityOptions,

Infrastructure\ControllerActionInvokerCacheTest.cs (1)

96var mvcOptions = Options.Create(new MvcOptions());

Infrastructure\ControllerActionInvokerTest.cs (2)

1705var options = Options.Create(new MvcOptions()); 1709services.AddSingleton<IOptions<MvcOptions>>(options);

Infrastructure\DefaultApiProblemDetailsWriterTest.cs (1)

229var mvcOptions = Options.Create(new MvcOptions());

Infrastructure\ObjectResultExecutorTest.cs (1)

480var optionsAccessor = Options.Create(options);

ModelBinding\Binders\ComplexObjectModelBinderTest.cs (1)

1086var options = Options.Create(new MvcOptions());

ModelBinding\Binders\ComplexTypeModelBinderTest.cs (1)

1248var options = Options.Create(new MvcOptions());

ModelBinding\Binders\HeaderModelBinderProviderTest.cs (1)

181var options = context.Services.GetRequiredService<IOptions<MvcOptions>>().Value;

ModelBinding\ModelBinderFactoryTest.cs (13)

ModelBinding\ParameterBinderTest.cs (2)

26private static readonly IOptions<MvcOptions> _optionsAccessor = Options.Create(new MvcOptions()); 743IOptions<MvcOptions> optionsAccessor = null,

ObjectResultTests.cs (1)

159var options = Options.Create(new MvcOptions());

RequireHttpsAttributeTests.cs (3)

168var options = Options.Create(new MvcOptions()); 235var options = Options.Create(new MvcOptions()); 240services.AddSingleton<IOptions<MvcOptions>>(options);

ResponseCacheAttributeTest.cs (2)

326var optionsAccessor = Options.Create(new MvcOptions()); 336.Setup(s => s.GetService(typeof(IOptions<MvcOptions>)))

Routing\AttributeRoutingTest.cs (1)

166var routeOptions = new Mock<IOptions<RouteOptions>>();

TestModelBinderFactory.cs (7)

15var options = serviceProvider.GetRequiredService<IOptions<MvcOptions>>(); 36var options = Options.Create(new MvcOptions()); 58var options = Options.Create(new MvcOptions()); 67protected TestModelBinderFactory(IModelMetadataProvider metadataProvider, IOptions<MvcOptions> options) 74IOptions<MvcOptions> options, 80private static IServiceProvider GetServices(IOptions<MvcOptions> options)

TestModelMetadataProvider.cs (1)

18var localizationOptions = Options.Create(new MvcDataAnnotationsLocalizationOptions());

TestModelValidatorProvider.cs (1)

15var options = Options.Create(new MvcDataAnnotationsLocalizationOptions());

CorsApplicationModelProvider.cs (1)

16public CorsApplicationModelProvider(IOptions<MvcOptions> mvcOptions)

CorsApplicationModelProviderTest.cs (1)

20private readonly IOptions<MvcOptions> OptionsWithoutEndpointRouting = Options.Create(new MvcOptions { EnableEndpointRouting = false });

DataAnnotationsClientModelValidatorProvider.cs (3)

20private readonly IOptions<MvcDataAnnotationsLocalizationOptions> _options; 29/// <param name="options">The <see cref="IOptions{MvcDataAnnotationsLocalizationOptions}"/>.</param> 33IOptions<MvcDataAnnotationsLocalizationOptions> options,

DataAnnotationsMetadataProvider.cs (1)

30IOptions<MvcDataAnnotationsLocalizationOptions> localizationOptions,

DataAnnotationsModelValidatorProvider.cs (3)

18private readonly IOptions<MvcDataAnnotationsLocalizationOptions> _options; 27/// <param name="options">The <see cref="IOptions{MvcDataAnnotationsLocalizationOptions}"/>.</param> 33IOptions<MvcDataAnnotationsLocalizationOptions> options,

DependencyInjection\MvcDataAnnotationsMvcOptionsSetup.cs (3)

18private readonly IOptions<MvcDataAnnotationsLocalizationOptions> _dataAnnotationLocalizationOptions; 22IOptions<MvcDataAnnotationsLocalizationOptions> dataAnnotationLocalizationOptions) 33IOptions<MvcDataAnnotationsLocalizationOptions> dataAnnotationLocalizationOptions,

MvcDataAnnotationsMvcOptionsSetup.cs (1)

21services.AddSingleton<IOptions<MvcDataAnnotationsLocalizationOptions>>(

XmlDataContractSerializerOutputFormatter.cs (1)

224_mvcOptions ??= httpContext.RequestServices.GetRequiredService<IOptions<MvcOptions>>().Value;

XmlSerializerOutputFormatter.cs (1)

203_mvcOptions ??= httpContext.RequestServices.GetRequiredService<IOptions<MvcOptions>>().Value;

AntiforgeryMiddlewareTest.cs (8)

37var antiforgeryOptions = app.Services.GetRequiredService<IOptions<AntiforgeryOptions>>(); 121var antiforgeryOptions = app.Services.GetRequiredService<IOptions<AntiforgeryOptions>>(); 153var antiforgeryOptions = app.Services.GetRequiredService<IOptions<AntiforgeryOptions>>(); 185var antiforgeryOptions = app.Services.GetRequiredService<IOptions<AntiforgeryOptions>>();

SimpleWithWebApplicationBuilderTests.cs (2)

266var antiforgeryOptions = _fixture.Services.GetRequiredService<IOptions<AntiforgeryOptions>>();

BodyValidationIntegrationTests.cs (2)

453var options = testContext.GetService<IOptions<MvcNewtonsoftJsonOptions>>().Value; 559var options = testContext.GetService<IOptions<MvcNewtonsoftJsonOptions>>().Value;

HasValidatorsValidationMetadataProviderIntegrationTest.cs (4)

25var options = services.GetRequiredService<IOptions<MvcOptions>>(); 43var options = services.GetRequiredService<IOptions<MvcOptions>>();

ModelBindingTestHelper.cs (12)

31var options = services.GetRequiredService<IOptions<MvcOptions>>(); 70var options = serviceProvider.GetRequiredService<IOptions<MvcOptions>>(); 90var options = services.GetRequiredService<IOptions<MvcOptions>>(); 119var options = services.GetRequiredService<IOptions<MvcOptions>>(); 126IOptions<MvcOptions> options = null) 134private static IList<IModelValidatorProvider> GetModelValidatorProviders(IOptions<MvcOptions> options) 177var optionsAccessor = services.GetRequiredService<IOptions<MvcOptions>>();

ParameterBinderExtensions.cs (2)

21var optionsAccessor = context.HttpContext.RequestServices.GetService<IOptions<MvcOptions>>();

TestMvcOptions.cs (2)

24var dataAnnotationLocalizationOptions = Options.Create(new MvcDataAnnotationsLocalizationOptions()); 38var jsonOptions = Options.Create(new MvcNewtonsoftJsonOptions());

TryValidateModelIntegrationTest.cs (2)

213var options = actionContext.HttpContext.RequestServices.GetRequiredService<IOptions<MvcOptions>>();

ValidationIntegrationTests.cs (1)

2518var options = services.GetRequiredService<IOptions<MvcOptions>>().Value;

MvcLocalizationMvcBuilderExtensionsTest.cs (4)

97var actualOptions = serviceProvider.GetRequiredService<IOptions<LocalizationOptions>>(); 121var actualOptions = serviceProvider.GetRequiredService<IOptions<MvcDataAnnotationsLocalizationOptions>>();

MvcLocalizationMvcCoreBuilderExtensionsTest.cs (4)

97var actualOptions = serviceProvider.GetRequiredService<IOptions<LocalizationOptions>>(); 121var actualOptions = serviceProvider.GetRequiredService<IOptions<MvcDataAnnotationsLocalizationOptions>>();

DependencyInjection\NewtonsoftJsonMvcOptionsSetup.cs (1)

29IOptions<MvcNewtonsoftJsonOptions> jsonOptions,

NewtonsoftJsonHelper.cs (1)

30public NewtonsoftJsonHelper(IOptions<MvcNewtonsoftJsonOptions> options, ArrayPool<char> charPool)

NewtonsoftJsonOutputFormatter.cs (1)

140_jsonOptions ??= context.HttpContext.RequestServices.GetRequiredService<IOptions<MvcNewtonsoftJsonOptions>>().Value;

NewtonsoftJsonResultExecutor.cs (2)

45IOptions<MvcOptions> mvcOptions, 46IOptions<MvcNewtonsoftJsonOptions> jsonOptions,

RazorViewEngine.cs (1)

53IOptions<RazorViewEngineOptions> optionsAccessor,

PageActionDescriptorChangeProvider.cs (1)

23IOptions<RazorPagesOptions> razorPagesOptions)

RazorProjectPageRouteModelProvider.cs (1)

23IOptions<RazorPagesOptions> pagesOptionsAccessor,

RazorReferenceManager.cs (1)

24IOptions<MvcRazorRuntimeCompilationOptions> options)

RuntimeCompilationFileProvider.cs (1)

14public RuntimeCompilationFileProvider(IOptions<MvcRazorRuntimeCompilationOptions> options)

FileProviderRazorProjectFileSystemTest.cs (1)

246var options = Options.Create(new MvcRazorRuntimeCompilationOptions

RuntimeCompilationFileProviderTest.cs (1)

19var options = Options.Create(new MvcRazorRuntimeCompilationOptions());

RuntimeViewCompilerTest.cs (1)

823var options = Options.Create(new MvcRazorRuntimeCompilationOptions

RazorViewEngineOptionsTest.cs (4)

34var accessor = serviceProvider.GetRequiredService<IOptions<RazorViewEngineOptions>>(); 64var accessor = serviceProvider.GetRequiredService<IOptions<RazorViewEngineOptions>>();

RazorViewEngineTest.cs (3)

2060private static IOptions<RazorViewEngineOptions> GetOptionsAccessor( 2111var optionsAccessor = new Mock<IOptions<RazorViewEngineOptions>>(); 2156IOptions<RazorViewEngineOptions> optionsAccessor)

ApplicationModels\AuthorizationPageApplicationModelProvider.cs (1)

18IOptions<MvcOptions> mvcOptions)

ApplicationModels\CompiledPageRouteModelProvider.cs (1)

26IOptions<RazorPagesOptions> pagesOptionsAccessor,

ApplicationModels\DefaultPageApplicationModelProvider.cs (1)

28IOptions<RazorPagesOptions> razorPagesOptions,

ApplicationModels\PageConventionCollection.cs (1)

47_mvcOptions ??= _serviceProvider!.GetRequiredService<IOptions<MvcOptions>>().Value;

ApplicationModels\ResponseCacheFilterApplicationModelProvider.cs (1)

16public ResponseCacheFilterApplicationModelProvider(IOptions<MvcOptions> mvcOptionsAccessor, ILoggerFactory loggerFactory)

DependencyInjection\RazorPagesRazorViewEngineOptionsSetup.cs (1)

16public RazorPagesRazorViewEngineOptionsSetup(IOptions<RazorPagesOptions> pagesOptions)

Infrastructure\CompiledPageActionDescriptorProvider.cs (2)

36IOptions<MvcOptions> mvcOptions, 37IOptions<RazorPagesOptions> pageOptions)

Infrastructure\DefaultPageLoader.cs (2)

24IOptions<RazorPagesOptions> pageOptions, 25IOptions<MvcOptions> mvcOptions)

Infrastructure\PageActionDescriptorProvider.cs (2)

30IOptions<MvcOptions> mvcOptionsAccessor, 31IOptions<RazorPagesOptions> pagesOptionsAccessor)

Infrastructure\PageActionInvokerProvider.cs (2)

35IOptions<MvcOptions> mvcOptions, 36IOptions<MvcViewOptions> mvcViewOptions,

Infrastructure\PageRequestDelegateFactory.cs (4)

36IOptions<MvcOptions> mvcOptions, 37IOptions<MvcViewOptions> mvcViewOptions, 50IOptions<MvcOptions> mvcOptions, 51IOptions<MvcViewOptions> mvcViewOptions,

ApplicationModels\AuthorizationPageApplicationModelProviderTest.cs (2)

17private readonly IOptions<MvcOptions> OptionsWithoutEndpointRouting = Options.Create(new MvcOptions { EnableEndpointRouting = false }); 110var options = Options.Create(new AuthorizationOptions());

ApplicationModels\CompiledPageRouteModelProviderTest.cs (1)

493IOptions<RazorPagesOptions> options,

ApplicationModels\ResponseCacheFilterApplicationModelProviderTest.cs (3)

22var options = Options.Create(new MvcOptions()); 56var options = Options.Create(new MvcOptions()); 98var options = Options.Create(new MvcOptions());

DependencyInjection\MvcRazorPagesMvcBuilderExtensionsTest.cs (2)

29var accessor = serviceProvider.GetRequiredService<IOptions<RazorPagesOptions>>();

DependencyInjection\PageConventionCollectionExtensionsTest.cs (1)

980.AddSingleton<IOptions<MvcOptions>>(Options.Options.Create(options))

Infrastructure\DefaultPageLoaderTest.cs (7)

20private readonly IOptions<RazorPagesOptions> RazorPagesOptions = Options.Create(new RazorPagesOptions { Conventions = new PageConventionCollection(Mock.Of<IServiceProvider>()) }); 37var mvcOptions = Options.Create(new MvcOptions()); 120var mvcOptions = Options.Create(new MvcOptions()); 160var mvcOptions = Options.Create(new MvcOptions()); 237var mvcOptions = Options.Create(new MvcOptions()); 299var mvcOptions = Options.Create(new MvcOptions()); 336var mvcOptions = Options.Create(new MvcOptions());

Infrastructure\PageActionDescriptorProviderTest.cs (4)

271var options = GetRazorPagesOptions(); 361private static IOptions<TOptions> GetAccessor<TOptions>(TOptions options = null) 364var accessor = new Mock<IOptions<TOptions>>(); 369private static IOptions<RazorPagesOptions> GetRazorPagesOptions()

Infrastructure\PageBinderFactoryTest.cs (1)

21private static readonly IOptions<MvcOptions> _optionsAccessor = Options.Create(_options);

CacheTagHelperMemoryCacheFactory.cs (1)

19public CacheTagHelperMemoryCacheFactory(IOptions<CacheTagHelperOptions> options)

DistributedCacheTagHelperTest.cs (1)

774private static IDistributedCacheTagHelperStorage GetStorage(IOptions<MemoryDistributedCacheOptions> options = null)

TestableHtmlGenerator.cs (3)

41IOptions<MvcViewOptions> options, 119private static IOptions<MvcViewOptions> GetOptions() 121var mockOptions = new Mock<IOptions<MvcViewOptions>>();

MvcOptionsSetupTest.cs (1)

281return serviceProvider.GetRequiredService<IOptions<T>>().Value;

CookieTempDataProvider.cs (1)

41IOptions<CookieTempDataProviderOptions> options,

DefaultHtmlGenerator.cs (1)

57IOptions<MvcViewOptions> optionsAccessor,

DefaultValidationHtmlAttributeProvider.cs (1)

28IOptions<MvcViewOptions> optionsAccessor,

DependencyInjection\MvcViewOptionsSetup.cs (3)

16private readonly IOptions<MvcDataAnnotationsLocalizationOptions> _dataAnnotationsLocalizationOptions; 21IOptions<MvcDataAnnotationsLocalizationOptions> dataAnnotationLocalizationOptions, 32IOptions<MvcDataAnnotationsLocalizationOptions> dataAnnotationOptions,

Filters\AntiforgeryApplicationModelProvider.cs (1)

12internal sealed class AntiforgeryApplicationModelProvider(IOptions<MvcOptions> mvcOptions, ILogger<AntiforgeryMiddlewareAuthorizationFilter> logger) : IApplicationModelProvider

PartialViewResultExecutor.cs (2)

28/// <param name="viewOptions">The <see cref="IOptions{MvcViewOptions}"/>.</param> 36IOptions<MvcViewOptions> viewOptions,

RemoteAttributeBase.cs (2)

180var options = services.GetRequiredService<IOptions<MvcDataAnnotationsLocalizationOptions>>();

Rendering\SystemTextJsonHelper.cs (1)

15public SystemTextJsonHelper(IOptions<JsonOptions> options)

ViewComponentResultExecutor.cs (2)

38/// <param name="mvcHelperOptions">The <see cref="IOptions{MvcViewOptions}"/>.</param> 45IOptions<MvcViewOptions> mvcHelperOptions,

ViewEngines\CompositeViewEngine.cs (1)

19public CompositeViewEngine(IOptions<MvcViewOptions> optionsAccessor)

ViewExecutor.cs (2)

32/// <param name="viewOptions">The <see cref="IOptions{MvcViewOptions}"/>.</param> 39IOptions<MvcViewOptions> viewOptions,

ViewResultExecutor.cs (2)

28/// <param name="viewOptions">The <see cref="IOptions{MvcViewOptions}"/>.</param> 36IOptions<MvcViewOptions> viewOptions,

CookieTempDataProviderTest.cs (1)

400var testOptions = new Mock<IOptions<CookieTempDataProviderOptions>>();

DefaultHtmlGeneratorTest.cs (1)

1004var mvcViewOptionsAccessor = new Mock<IOptions<MvcViewOptions>>();

DefaultValidationHtmlAttributeProviderTest.cs (1)

274var mvcViewOptionsAccessor = new Mock<IOptions<MvcViewOptions>>();

PageRemoteAttributeTest.cs (1)

193provider => new DefaultInlineConstraintResolver(provider.GetRequiredService<IOptions<RouteOptions>>(), provider));

PartialViewResultExecutorTest.cs (1)

358var options = Options.Create(new MvcViewOptions());

PartialViewResultTest.cs (1)

233var options = Options.Create(new MvcViewOptions());

RemoteAttributeBaseTest.cs (8)

223var options = context.ActionContext.HttpContext.RequestServices 224.GetRequiredService<IOptions<MvcDataAnnotationsLocalizationOptions>>(); 270var options = context.ActionContext.HttpContext.RequestServices 271.GetRequiredService<IOptions<MvcDataAnnotationsLocalizationOptions>>(); 315var options = context.ActionContext.HttpContext.RequestServices 316.GetRequiredService<IOptions<MvcDataAnnotationsLocalizationOptions>>(); 407var options = context.ActionContext.HttpContext.RequestServices 408.GetRequiredService<IOptions<MvcDataAnnotationsLocalizationOptions>>();

RemoteAttributeTest.cs (1)

494provider => new DefaultInlineConstraintResolver(provider.GetRequiredService<IOptions<RouteOptions>>(), provider));

Rendering\DefaultTemplatesUtilities.cs (1)

238var localizationOptionsAccesor = Options.Create(localizationOptions);

ViewEngines\CompositeViewEngineTest.cs (16)

ViewResultExecutorTest.cs (1)

348var options = Options.Create(new MvcViewOptions());

ViewResultTest.cs (1)

245var options = Options.Create(new MvcViewOptions());

HtmlGeneratorUtilities.cs (1)

29var optionsAccessor = new Mock<IOptions<MvcViewOptions>>();

Services\OpenApiDocumentServiceTestsBase.cs (2)

51var optionsAccessor = Options.Create(options); 271if (serviceType == typeof(IOptions<RouteHandlerOptions>))

OutputCacheKeyProvider.cs (1)

23internal OutputCacheKeyProvider(ObjectPoolProvider poolProvider, IOptions<OutputCacheOptions> options)

OutputCacheMiddleware.cs (2)

40IOptions<OutputCacheOptions> options, 56IOptions<OutputCacheOptions> options,

OutputCacheServiceCollectionExtensions.cs (2)

33var outputCacheOptions = sp.GetRequiredService<IOptions<OutputCacheOptions>>();

Policies\NamedPolicy.cs (2)

15private IOptions<OutputCacheOptions>? _options; 72_options ??= context.HttpContext.RequestServices.GetRequiredService<IOptions<OutputCacheOptions>>();

Policies\TypedPolicy.cs (2)

33var options = context.HttpContext.RequestServices.GetRequiredService<IOptions<OutputCacheOptions>>();

RedisOutputCacheStore.cs (2)

52public RedisOutputCacheStore(IOptions<RedisOutputCacheOptions> optionsAccessor) // TODO: OC-specific options? 70internal RedisOutputCacheStore(IOptions<RedisOutputCacheOptions> optionsAccessor, ILogger logger)

RedisOutputCacheStoreImpl.cs (2)

11public RedisOutputCacheStoreImpl(IOptions<RedisOutputCacheOptions> optionsAccessor, ILogger<RedisOutputCacheStore> logger) 16public RedisOutputCacheStoreImpl(IOptions<RedisOutputCacheOptions> optionsAccessor)

TestUtils.cs (2)

225serviceProvider.Setup(x => x.GetService(typeof(IOptions<OutputCacheOptions>))).Returns(Options.Create(options ?? new OutputCacheOptions())); 245serviceProvider.Setup(x => x.GetService(typeof(IOptions<OutputCacheOptions>))).Returns(Options.Create(options ?? new OutputCacheOptions()));

RateLimitingMiddleware.cs (1)

35public RateLimitingMiddleware(RequestDelegate next, ILogger<RateLimitingMiddleware> logger, IOptions<RateLimiterOptions> options, IServiceProvider serviceProvider, RateLimitingMetrics metrics)

RateLimitingMetricsTests.cs (7)

30var options = CreateOptionsAccessor(); 70var options = CreateOptionsAccessor(); 129var options = CreateOptionsAccessor(); 187serviceProvider.GetRequiredService<IOptions<RateLimiterOptions>>(), 262serviceProvider.GetRequiredService<IOptions<RateLimiterOptions>>(), 335private RateLimitingMiddleware CreateTestRateLimitingMiddleware(IOptions<RateLimiterOptions> options, ILogger<RateLimitingMiddleware> logger = null, IServiceProvider serviceProvider = null, IMeterFactory meterFactory = null, RequestDelegate next = null) 346private IOptions<RateLimiterOptions> CreateOptionsAccessor() => Options.Create(new RateLimiterOptions());

RateLimitingMiddlewareTests.cs (20)

DefaultRequestDecompressionProvider.cs (1)

20IOptions<RequestDecompressionOptions> options)

DefaultRequestDecompressionProviderTests.cs (6)

32var options = Options.Create(new RequestDecompressionOptions()); 58var options = Options.Create(new RequestDecompressionOptions()); 85var options = Options.Create(new RequestDecompressionOptions()); 113var options = Options.Create(new RequestDecompressionOptions()); 136IOptions<RequestDecompressionOptions> options = null; 150var options = Options.Create(new RequestDecompressionOptions());

ResponseCachingKeyProvider.cs (1)

22internal ResponseCachingKeyProvider(ObjectPoolProvider poolProvider, IOptions<ResponseCachingOptions> options)

ResponseCachingMiddleware.cs (2)

41IOptions<ResponseCachingOptions> options, 59IOptions<ResponseCachingOptions> options,

BrotliCompressionProvider.cs (1)

18public BrotliCompressionProvider(IOptions<BrotliCompressionProviderOptions> options)

BrotliCompressionProviderOptions.cs (1)

20BrotliCompressionProviderOptions IOptions<BrotliCompressionProviderOptions>.Value => this;

GzipCompressionProvider.cs (1)

18public GzipCompressionProvider(IOptions<GzipCompressionProviderOptions> options)

GzipCompressionProviderOptions.cs (1)

20GzipCompressionProviderOptions IOptions<GzipCompressionProviderOptions>.Value => this;

ResponseCompressionProvider.cs (1)

30public ResponseCompressionProvider(IServiceProvider services, IOptions<ResponseCompressionOptions> options)

RewriteBuilderExtensions.cs (2)

45private static IApplicationBuilder AddRewriteMiddleware(IApplicationBuilder app, IOptions<RewriteOptions>? options) 54options = app.ApplicationServices.GetRequiredService<IOptions<RewriteOptions>>();

RewriteMiddleware.cs (1)

36IOptions<RewriteOptions> options)

Builder\EndpointRouteBuilderExtensions.cs (2)

458var routeHandlerOptions = endpoints.ServiceProvider?.GetService<IOptions<RouteHandlerOptions>>();

Builder\EndpointRoutingApplicationBuilderExtensions.cs (2)

104var routeOptions = builder.ApplicationServices.GetRequiredService<IOptions<RouteOptions>>();

DefaultInlineConstraintResolver.cs (1)

31public DefaultInlineConstraintResolver(IOptions<RouteOptions> routeOptions, IServiceProvider serviceProvider)

DefaultLinkGenerator.cs (1)

41IOptions<RouteOptions> routeOptions,

DefaultParameterPolicyFactory.cs (1)

16IOptions<RouteOptions> options,

EndpointMiddleware.cs (1)

26IOptions<RouteOptions> routeOptions)

EndpointRoutingMiddleware.cs (1)

40IOptions<RouteOptions> routeOptions,

RequestDelegateFilterPipelineBuilder.cs (1)

22var jsonOptions = serviceProvider?.GetService<IOptions<JsonOptions>>()?.Value ?? new JsonOptions();

RouteCollection.cs (1)

195_options = context.RequestServices.GetRequiredService<IOptions<RouteOptions>>().Value;

MinimalFormTests.cs (14)

52var antiforgeryOptions = host.Services.GetRequiredService<IOptions<AntiforgeryOptions>>(); 112var antiforgeryOptions = host.Services.GetRequiredService<IOptions<AntiforgeryOptions>>(); 473var antiforgeryOptions = host.Services.GetRequiredService<IOptions<AntiforgeryOptions>>(); 532var antiforgeryOptions = host.Services.GetRequiredService<IOptions<AntiforgeryOptions>>(); 584var antiforgeryOptions = host.Services.GetRequiredService<IOptions<AntiforgeryOptions>>(); 636var antiforgeryOptions = host.Services.GetRequiredService<IOptions<AntiforgeryOptions>>(); 685var antiforgeryOptions = host.Services.GetRequiredService<IOptions<AntiforgeryOptions>>();

Builder\EndpointRoutingApplicationBuilderExtensionsTest.cs (2)

323var routeOptions = app.ApplicationServices.GetRequiredService<IOptions<RouteOptions>>();

Builder\RouteHandlerEndpointRouteBuilderExtensionsTest.cs (1)

1179else if (serviceType == typeof(IOptions<RouteHandlerOptions>))

DefaultInlineConstraintResolverTest.cs (1)

368var optionsAccessor = new Mock<IOptions<RouteOptions>>();

EndpointMiddlewareTest.cs (4)

16private readonly IOptions<RouteOptions> RouteOptions = Options.Create(new RouteOptions()); 205var routeOptions = Options.Create(new RouteOptions { SuppressCheckForUnhandledSecurityMetadata = true }); 302var routeOptions = Options.Create(new RouteOptions { SuppressCheckForUnhandledSecurityMetadata = true }); 400var routeOptions = Options.Create(new RouteOptions { SuppressCheckForUnhandledSecurityMetadata = true });

InlineRouteParameterParserTests.cs (2)

965var accessor = serviceProvider.GetRequiredService<IOptions<RouteOptions>>();

LinkGeneratorTestBase.cs (2)

71var routeOptions = serviceProvider.GetRequiredService<IOptions<RouteOptions>>();

LinkParserTestBase.cs (2)

63var routeOptions = serviceProvider.GetRequiredService<IOptions<RouteOptions>>();

RouteCollectionTest.cs (2)

659var optionsAccessor = new Mock<IOptions<RouteOptions>>(MockBehavior.Strict); 665context.Setup(m => m.RequestServices.GetService(typeof(IOptions<RouteOptions>)))

RouteConstraintBuilderTest.cs (1)

179var options = new Mock<IOptions<RouteOptions>>(MockBehavior.Strict);

RouteHandlerOptionsTests.cs (4)

29var options = serviceProvider.GetRequiredService<IOptions<RouteHandlerOptions>>().Value; 53var options = serviceProvider.GetRequiredService<IOptions<RouteHandlerOptions>>().Value; 65var options = serviceProvider.GetRequiredService<IOptions<RouteHandlerOptions>>();

RouteOptionsTests.cs (3)

24var accessor = serviceProvider.GetRequiredService<IOptions<RouteOptions>>(); 40var options = serviceProvider.GetRequiredService<IOptions<RouteOptions>>().Value;

RouteTest.cs (1)

1853var routeOptionsMock = new Mock<IOptions<RouteOptions>>();

RoutingServiceCollectionExtensionsTests.cs (2)

79var options = provider.GetService<IOptions<RouteOptions>>();

TemplateParserDefaultValuesTests.cs (2)

148var accessor = serviceProvider.GetRequiredService<IOptions<RouteOptions>>();

Tree\TreeRouteBuilderTest.cs (2)

259var accessor = serviceProvider.GetRequiredService<IOptions<RouteOptions>>();

Tree\TreeRouterTest.cs (1)

2062var optionsMock = new Mock<IOptions<RouteOptions>>();

MessagePump.cs (1)

30public MessagePump(IOptions<HttpSysOptions> options, ILoggerFactory loggerFactory, IAuthenticationSchemeProvider authentication)

WebHostBuilderHttpSysExtensions.cs (1)

40var options = services.GetRequiredService<IOptions<HttpSysOptions>>().Value;

src\Shared\Http2cat\Http2CatHostedService.cs (1)

32IOptions<Http2CatOptions> options, IHostApplicationLifetime hostApplicationLifetime)

Utilities.cs (2)

106var options = host.Services.GetRequiredService<IOptions<HttpSysOptions>>();

Core\IISHttpServer.cs (1)

63IOptions<IISServerOptions> options,

IISMiddleware.cs (2)

50IOptions<IISOptions> options, 70IOptions<IISOptions> options,

Internal\KestrelServerImpl.cs (2)

37IOptions<KestrelServerOptions> options, 75private static ServiceContext CreateServiceContext(IOptions<KestrelServerOptions> options, ILoggerFactory loggerFactory, DiagnosticSource? diagnosticSource, KestrelMetrics metrics)

KestrelServer.cs (2)

28/// <param name="options">The Kestrel <see cref="IOptions{TOptions}"/>.</param> 31public KestrelServer(IOptions<KestrelServerOptions> options, IConnectionListenerFactory transportFactory, ILoggerFactory loggerFactory)

Internal\NamedPipeTransportFactory.cs (1)

23IOptions<NamedPipeTransportOptions> options,

QuicTransportFactory.cs (1)

21public QuicTransportFactory(ILoggerFactory loggerFactory, IOptions<QuicTransportOptions> options)

Client\SocketConnectionFactory.cs (1)

24public SocketConnectionFactory(IOptions<SocketTransportOptions> options, ILoggerFactory loggerFactory)

SocketTransportFactory.cs (1)

26IOptions<SocketTransportOptions> options,

SessionMiddleware.cs (1)

40IOptions<SessionOptions> options)

HubConnectionBuilderHttpExtensions.cs (1)

170public HttpConnectionOptionsDerivedHttpEndPoint(IOptions<HttpConnectionOptions> httpConnectionOptions)

HubConnection.cs (3)

238var options = serviceProvider.GetService<IOptions<HubConnectionOptions>>(); 1985_hubConnection._serviceProvider.GetService<IOptions<HubConnectionOptions>>()?.Value.StatefulReconnectBufferSize

HubConnectionBuilderExtensionsTests.cs (5)

27var value = serviceProvider.GetService<IOptions<HttpConnectionOptions>>().Value; 40var value = serviceProvider.GetService<IOptions<HttpConnectionOptions>>().Value; 54var value = serviceProvider.GetService<IOptions<HttpConnectionOptions>>().Value; 70var value = serviceProvider.GetService<IOptions<HttpConnectionOptions>>().Value; 85var value = serviceProvider.GetService<IOptions<HttpConnectionOptions>>().Value;

HubConnectionHandler.cs (2)

50IOptions<HubOptions> globalHubOptions, 51IOptions<HubOptions<THub>> hubOptions,

HubOptionsSetup`T.cs (1)

20public HubOptionsSetup(IOptions<HubOptions> options)

RedisHubLifetimeManagerBenchmark.cs (1)

40var options = Options.Create(new RedisOptions()

Protocol\JsonHubProtocol.cs (1)

68public JsonHubProtocol(IOptions<JsonHubProtocolOptions> options)

Protocol\MessagePackHubProtocol.cs (1)

46public MessagePackHubProtocol(IOptions<MessagePackHubProtocolOptions> options)

Protocol\NewtonsoftJsonHubProtocol.cs (1)

58public NewtonsoftJsonHubProtocol(IOptions<NewtonsoftJsonHubProtocolOptions> options)

RedisHubLifetimeManager.cs (4)

51IOptions<RedisOptions> options, 66IOptions<RedisOptions> options, 68IOptions<HubOptions>? globalHubOptions, 69IOptions<HubOptions<THub>>? hubOptions)

RedisDependencyInjectionExtensionsTests.cs (2)

27var options = provider.GetService<IOptions<RedisOptions>>();

AddSignalRTests.cs (9)

HubConnectionHandlerTests.cs (6)

2457var msgPackOptions = serviceProvider.GetRequiredService<IOptions<MessagePackHubProtocolOptions>>(); 2495var msgPackOptions = serviceProvider.GetRequiredService<IOptions<MessagePackHubProtocolOptions>>(); 2519var msgPackOptions = serviceProvider.GetRequiredService<IOptions<MessagePackHubProtocolOptions>>();

SpaProxyLaunchManager.cs (1)

26IOptions<SpaDevelopmentServerOptions> options)

SpaProxyMiddleware.cs (2)

26private readonly IOptions<SpaDevelopmentServerOptions> _options; 33IOptions<SpaDevelopmentServerOptions> options,

SpaApplicationBuilderExtensions.cs (2)

34var optionsProvider = app.ApplicationServices.GetService<IOptions<SpaOptions>>()!;

StaticFiles\SpaStaticFilesExtensions.cs (2)

30var optionsProvider = serviceProvider.GetService<IOptions<SpaStaticFilesOptions>>()!;

DefaultFilesMiddleware.cs (1)

30public DefaultFilesMiddleware(RequestDelegate next, IWebHostEnvironment hostingEnv, IOptions<DefaultFilesOptions> options)

DirectoryBrowserMiddleware.cs (2)

30public DirectoryBrowserMiddleware(RequestDelegate next, IWebHostEnvironment hostingEnv, IOptions<DirectoryBrowserOptions> options) 42public DirectoryBrowserMiddleware(RequestDelegate next, IWebHostEnvironment hostingEnv, HtmlEncoder encoder, IOptions<DirectoryBrowserOptions> options)

StaticFileMiddleware.cs (1)

32public StaticFileMiddleware(RequestDelegate next, IWebHostEnvironment hostingEnv, IOptions<StaticFileOptions> options, ILoggerFactory loggerFactory)

TestServer.cs (2)

35public TestServer(IServiceProvider services, IOptions<TestServerOptions> optionsAccessor) 46public TestServer(IServiceProvider services, IFeatureCollection featureCollection, IOptions<TestServerOptions> optionsAccessor)

WebApplicationTests.cs (1)

2424Assert.Contains(builder.Services, service => service.ServiceType == typeof(IOptions<>));

WebHostTests.cs (2)

121var routeOptions = host.Services.GetService<IOptions<RouteOptions>>();

WebSocketMiddleware.cs (1)

35public WebSocketMiddleware(RequestDelegate next, IOptions<WebSocketOptions> options, ILoggerFactory loggerFactory)

AddWebSocketsTests.cs (1)

24var socketOptions = services.GetRequiredService<IOptions<WebSocketOptions>>().Value;

Internal\DefaultHybridCache.cs (1)

55public DefaultHybridCache(IOptions<HybridCacheOptions> options, IServiceProvider services)

BufferReleaseTests.cs (1)

79public TestCache(IOptions<MemoryDistributedCacheOptions> options) : base(options) { }

L2Tests.cs (2)

19class Options<T>(T Value) : IOptions<T> where T : class 21T IOptions<T>.Value => Value;

ServiceConstructionTests.cs (4)

200public CustomMemoryCache(IOptions<MemoryCacheOptions> options) : base(options) { } 201public CustomMemoryCache(IOptions<MemoryCacheOptions> options, ILoggerFactory loggerFactory) : base(options, loggerFactory) { } 206public CustomMemoryDistributedCache(IOptions<MemoryDistributedCacheOptions> options) : base(options) { } 207public CustomMemoryDistributedCache(IOptions<MemoryDistributedCacheOptions> options, ILoggerFactory loggerFactory) : base(options, loggerFactory) { }

MemoryCache.cs (2)

38public MemoryCache(IOptions<MemoryCacheOptions> optionsAccessor) 46public MemoryCache(IOptions<MemoryCacheOptions> optionsAccessor, ILoggerFactory loggerFactory)

MemoryCacheOptions.cs (1)

87MemoryCacheOptions IOptions<MemoryCacheOptions>.Value

MemoryDistributedCache.cs (2)

25public MemoryDistributedCache(IOptions<MemoryDistributedCacheOptions> optionsAccessor) 33public MemoryDistributedCache(IOptions<MemoryDistributedCacheOptions> optionsAccessor, ILoggerFactory loggerFactory)

SqlServerCache.cs (1)

36public SqlServerCache(IOptions<SqlServerCacheOptions> options)

SqlServerCacheOptions.cs (1)

46SqlServerCacheOptions IOptions<SqlServerCacheOptions>.Value

RedisCache.cs (2)

82public RedisCache(IOptions<RedisCacheOptions> optionsAccessor) 92internal RedisCache(IOptions<RedisCacheOptions> optionsAccessor, ILogger logger)

RedisCacheImpl.cs (2)

11public RedisCacheImpl(IOptions<RedisCacheOptions> optionsAccessor, ILogger<RedisCache> logger) 16public RedisCacheImpl(IOptions<RedisCacheOptions> optionsAccessor)

RedisCacheOptions.cs (1)

45RedisCacheOptions IOptions<RedisCacheOptions>.Value

DefaultHealthCheckService.cs (2)

21private readonly IOptions<HealthCheckServiceOptions> _options; 26IOptions<HealthCheckServiceOptions> options,

HealthCheckPublisherHostedService.cs (4)

22private readonly IOptions<HealthCheckServiceOptions> _healthCheckServiceOptions; 23private readonly IOptions<HealthCheckPublisherOptions> _healthCheckPublisherOptions; 33IOptions<HealthCheckServiceOptions> healthCheckServiceOptions, 34IOptions<HealthCheckPublisherOptions> healthCheckPublisherOptions,

DefaultHealthCheckServiceTest.cs (2)

43var options = services.GetRequiredService<IOptions<HealthCheckServiceOptions>>();

DependencyInjection\HealthChecksBuilderTest.cs (10)

HostBuilder.cs (1)

322appServices.GetRequiredService<IOptions<HostOptions>>());

Internal\ConsoleLifetime.cs (4)

34public ConsoleLifetime(IOptions<ConsoleLifetimeOptions> options, IHostEnvironment environment, IHostApplicationLifetime applicationLifetime, IOptions<HostOptions> hostOptions) 46public ConsoleLifetime(IOptions<ConsoleLifetimeOptions> options, IHostEnvironment environment, IHostApplicationLifetime applicationLifetime, IOptions<HostOptions> hostOptions, ILoggerFactory loggerFactory)

Internal\Host.cs (1)

40IOptions<HostOptions> options)

WindowsServiceLifetime.cs (5)

32/// <param name="optionsAccessor">The <see cref="IOptions{HostOptions}"/> containing options for the service.</param> 33public WindowsServiceLifetime(IHostEnvironment environment, IHostApplicationLifetime applicationLifetime, ILoggerFactory loggerFactory, IOptions<HostOptions> optionsAccessor) 44/// <param name="optionsAccessor">The <see cref="IOptions{HostOptions}"/> containing options for the service.</param> 46public WindowsServiceLifetime(IHostEnvironment environment, IHostApplicationLifetime applicationLifetime, ILoggerFactory loggerFactory, IOptions<HostOptions> optionsAccessor, IOptions<WindowsServiceLifetimeOptions> windowsServiceOptionsAccessor)

PasswordHasher.cs (1)

45public PasswordHasher(IOptions<PasswordHasherOptions>? optionsAccessor = null)

UserClaimsPrincipalFactory.cs (2)

26IOptions<IdentityOptions> optionsAccessor) 116public UserClaimsPrincipalFactory(UserManager<TUser> userManager, RoleManager<TRole> roleManager, IOptions<IdentityOptions> options)

UserManager.cs (1)

70IOptions<IdentityOptions> optionsAccessor,

ResourceManagerStringLocalizerFactory.cs (2)

34/// <param name="localizationOptions">The <see cref="IOptions{LocalizationOptions}"/>.</param> 37IOptions<LocalizationOptions> localizationOptions,

StringLocalizerOfTRootNamespaceTest.cs (1)

18var options = new Mock<IOptions<LocalizationOptions>>();

ResourceManagerStringLocalizerFactoryTest.cs (12)

LoggerFactory.cs (2)

70public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption, IOptions<LoggerFactoryOptions>? options) : this(providers, filterOption, options, null) 81public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption, IOptions<LoggerFactoryOptions>? options = null, IExternalScopeProvider? scopeProvider = null)

EventLogLoggerProvider.cs (2)

38/// <param name="options">The <see cref="IOptions{EventLogSettings}"/>.</param> 39public EventLogLoggerProvider(IOptions<EventLogSettings> options)

Options.cs (2)

22/// Creates a wrapper around an instance of <typeparamref name="TOptions"/> to return itself as an <see cref="IOptions{TOptions}"/>. 27public static IOptions<TOptions> Create<[DynamicallyAccessedMembers(DynamicallyAccessedMembers)] TOptions>(TOptions options)

OptionsManager.cs (1)

10/// Implementation of <see cref="IOptions{TOptions}"/> and <see cref="IOptionsSnapshot{TOptions}"/>.

OptionsServiceCollectionExtensions.cs (1)

26services.TryAdd(ServiceDescriptor.Singleton(typeof(IOptions<>), typeof(UnnamedOptionsManager<>)));

OptionsWrapper.cs (1)

9/// <see cref="IOptions{TOptions}"/> wrapper that returns the options instance.

ValidateOnStart.cs (1)

15public StartupValidator(IOptions<StartupValidatorOptions> validators)

EncoderServiceCollectionExtensions.cs (1)

67?.GetService<IOptions<WebEncoderOptions>>()

HelloExtension\HelloMiddleware.cs (1)

15public HelloMiddleware(RequestDelegate next, IOptions<HelloOptions> helloOptions)

HelloExtension\HelloMiddleware.cs (1)

15public HelloMiddleware(RequestDelegate next, IOptions<HelloOptions> helloOptions)

src\Servers\Kestrel\test\BindTests\AddressRegistrationTests.cs (2)

330var options = ((IOptions<KestrelServerOptions>)host.Services.GetService(typeof(IOptions<KestrelServerOptions>))).Value;

Controllers\XmlDataContractApiController.cs (2)

26var mvcOptions = context.HttpContext.RequestServices.GetRequiredService<IOptions<MvcOptions>>();

Controllers\XmlSerializedApiController.cs (2)

26var mvcOptions = context.HttpContext.RequestServices.GetRequiredService<IOptions<MvcOptions>>();