IOptions

IOptionsSnapshot.cs (1)

21IOptions<TOptions>

Telemetry\DashboardTelemetrySenderTests.cs (1)

148public class TestDashboardOptions(DashboardOptions value) : IOptions<DashboardOptions>

Telemetry\DashboardTelemetryServiceTests.cs (1)

171public class TestDashboardOptions(DashboardOptions value) : IOptions<DashboardOptions>

DefaultTokenCredentialProviderTests.cs (1)

354private sealed class TestOptions<T>(T value) : IOptions<T> where T : class

ModelBinding\EmptyModelMetadataProvider.cs (1)

26private sealed class OptionsAccessor : IOptions<MvcOptions>

BrotliCompressionProviderOptions.cs (1)

12public class BrotliCompressionProviderOptions : IOptions<BrotliCompressionProviderOptions>

GzipCompressionProviderOptions.cs (1)

12public class GzipCompressionProviderOptions : IOptions<GzipCompressionProviderOptions>

ZstandardCompressionProviderOptions.cs (1)

12public class ZstandardCompressionProviderOptions : IOptions<ZstandardCompressionProviderOptions>

L2Tests.cs (1)

29private class Options<T>(T value) : IOptions<T>

Options.cs (1)

14private sealed class OptionsImpl<T> : IOptions<T>

MemoryCacheOptions.cs (1)

14public class MemoryCacheOptions : IOptions<MemoryCacheOptions>

SqlServerCacheOptions.cs (1)

13public class SqlServerCacheOptions : 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>

ConformanceTestsBase.cs (1)

80HealthCheckServiceOptions healthCheckServiceOptions = host.Services.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value;

Components\Pages\ConsoleLogs.razor.cs (1)

73public required IOptions<DashboardOptions> Options { get; init; }

Components\Pages\StructuredLogs.razor.cs (1)

94public required IOptions<DashboardOptions> DashboardOptions { get; init; }

Components\Pages\Traces.razor.cs (1)

78public required IOptions<DashboardOptions> DashboardOptions { get; init; }

DashboardWebApplication.cs (2)

411var corsOptions = _app.Services.GetRequiredService<IOptions<CorsOptions>>().Value; 803var options = context.HttpContext.RequestServices.GetRequiredService<IOptions<DashboardOptions>>().Value;

Otlp\Storage\SqliteTelemetryRepository.cs (1)

60IOptions<DashboardOptions> dashboardOptions,

ServiceClient\DashboardClient.cs (1)

99IOptions<DashboardOptions> dashboardOptions,

ServiceClient\DashboardRunStore.cs (2)

91public DashboardRunStore(IOptions<DashboardOptions> options, ILogger<DashboardRunStore> logger, TimeProvider timeProvider) 97IOptions<DashboardOptions> options,

ServiceClient\RepositoryFactory.cs (1)

22serviceProvider.GetRequiredService<IOptions<DashboardOptions>>(),

Telemetry\DashboardTelemetrySender.cs (2)

16private readonly IOptions<DashboardOptions> _options; 27public DashboardTelemetrySender(IOptions<DashboardOptions> options, ILogger<DashboardTelemetrySender> logger)

Pages\StructuredLogsTests.cs (1)

297Services.AddSingleton<IOptions<DashboardOptions>>(Options.Create(new DashboardOptions

Pages\TracesTests.cs (1)

72Services.AddSingleton<IOptions<DashboardOptions>>(Options.Create(new DashboardOptions

Shared\FluentUISetupHelpers.cs (5)

159var options = context.Services.GetRequiredService<IOptions<DashboardOptions>>(); 202var options = services.GetRequiredService<IOptions<DashboardOptions>>(); 247context.Services.AddSingleton<IOptions<DashboardOptions>>(Options.Create(new DashboardOptions()));

Integration\StartupTests.cs (4)

621var options = app.Services.GetRequiredService<IOptions<LoggerFilterOptions>>(); 663var options = app.Services.GetRequiredService<IOptions<LoggerFilterOptions>>();

Model\DashboardDataSourceTests.cs (31)

Shared\SqliteRepositoryTestHelpers.cs (1)

20IOptions<DashboardOptions>? dashboardOptions = null,

TelemetryRepositoryTests\TelemetryRepositoryTestBase.cs (1)

42var options = Options.Create(new global::Aspire.Dashboard.Configuration.DashboardOptions { TelemetryLimits = telemetryLimits });

tests\Shared\Telemetry\InMemoryTelemetryRepository.cs (1)

107public InMemoryTelemetryRepository(ILoggerFactory loggerFactory, IOptions<DashboardOptions> dashboardOptions, PauseManager pauseManager, IEnumerable<IOutgoingPeerResolver> outgoingPeerResolvers)

ApplicationModel\HostUrl.cs (4)

51var options = context.ExecutionContext.Services.GetRequiredService<IOptions<DcpOptions>>(); 110var options = context.ExecutionContext.Services.GetRequiredService<IOptions<DcpOptions>>();

ApplicationModel\ResourceNotificationService.cs (1)

77DefaultWaitBehavior = serviceProvider.GetService<IOptions<ResourceNotificationServiceOptions>>()?.Value.DefaultWaitBehavior ?? WaitBehavior.StopOnResourceUnavailable;

Backchannel\DashboardUrlsHelper.cs (1)

76var dashboardOptions = serviceProvider.GetService<IOptions<DashboardOptions>>()?.Value;

Dashboard\DashboardEventHandlers.cs (3)

33IOptions<DashboardOptions> dashboardOptions, 381var dcpOptions = @event.Services.GetRequiredService<IOptions<DcpOptions>>();

Dashboard\DashboardOptions.cs (1)

34internal class ConfigureDefaultDashboardOptions(IConfiguration configuration, IOptions<DcpOptions> dcpOptions) : IConfigureOptions<DashboardOptions>

Dashboard\DashboardServiceHost.cs (1)

46IOptions<DcpOptions> dcpOptions,

Dcp\ContainerCreator.cs (2)

51private readonly IOptions<DcpOptions> _options; 66IOptions<DcpOptions> options,

Dcp\DcpDependencyCheck.cs (1)

27public DcpDependencyCheck(IOptions<DcpOptions> dcpOptions)

Dcp\DcpExecutor.cs (2)

60private readonly IOptions<DcpOptions> _options; 96IOptions<DcpOptions> options,

Dcp\DcpHost.cs (1)

57IOptions<DcpOptions> dcpOptions,

Dcp\DcpNameGenerator.cs (2)

20private readonly IOptions<DcpOptions> _options; 29public DcpNameGenerator(IConfiguration configuration, IOptions<DcpOptions> options)

Dcp\KubernetesService.cs (1)

81internal sealed class KubernetesService(ILogger<KubernetesService> logger, IOptions<DcpOptions> dcpOptions, Locations locations, IConfiguration configuration) : IKubernetesService, IDisposable

Dcp\ProxylessEndpointPortAllocator.cs (1)

45public ProxylessEndpointPortAllocator(IOptions<DcpOptions> options)

Devcontainers\Codespaces\CodespacesResourceUrlRewriterService.cs (1)

12internal sealed class CodespacesResourceUrlRewriterService(ILogger<CodespacesResourceUrlRewriterService> logger, IOptions<CodespacesOptions> options, CodespacesUrlRewriter codespaceUrlRewriter, ResourceNotificationService resourceNotificationService) : BackgroundService

Devcontainers\Codespaces\CodespacesUrlRewriter.cs (1)

8internal sealed class CodespacesUrlRewriter(IOptions<CodespacesOptions> options)

Devcontainers\DevcontainerPortForwardingEventingSubscriber.cs (6)

14private readonly IOptions<CodespacesOptions> _codespacesOptions; 15private readonly IOptions<DevcontainersOptions> _devcontainersOptions; 16private readonly IOptions<SshRemoteOptions> _sshRemoteOptions; 20IOptions<CodespacesOptions> codespacesOptions, 21IOptions<DevcontainersOptions> devcontainersOptions, 22IOptions<SshRemoteOptions> sshRemoteOptions,

Devcontainers\DevcontainerSettingsWriter.cs (3)

13internal class DevcontainerSettingsWriter(ILogger<DevcontainerSettingsWriter> logger, IOptions<CodespacesOptions> codespaceOptions, IOptions<DevcontainersOptions> devcontainerOptions, IOptions<SshRemoteOptions> sshRemoteOptions) : IDisposable

DistributedApplicationBuilder.cs (1)

600_innerBuilder.Services.AddOptions<LoggerFilterOptions>().Configure<IOptions<PipelineLoggingOptions>>((filterLoggingOptions, pipelineLoggingOptions) =>

Lifecycle\TerminalHostEventingSubscriber.cs (2)

36IOptions<DcpOptions> dcpOptions, 39private readonly IOptions<DcpOptions> _dcpOptions = dcpOptions ?? throw new ArgumentNullException(nameof(dcpOptions));

Lifecycle\TerminalHostFailureDiagnosticService.cs (1)

36IOptions<DcpOptions> dcpOptions,

Orchestrator\ApplicationOrchestrator.cs (1)

52IOptions<DashboardOptions> dashboardOptions,

Pipelines\DistributedApplicationPipeline.cs (4)

72var options = context.Services.GetRequiredService<IOptions<PipelineOptions>>(); 683var pipelineOptions = context.Services.GetService<Microsoft.Extensions.Options.IOptions<PipelineOptions>>();

Pipelines\Internal\FileDeploymentStateManager.cs (1)

25IOptions<PipelineOptions> pipelineOptions) : DeploymentStateManagerBase<FileDeploymentStateManager>(logger)

Pipelines\PipelineLoggerProvider.cs (1)

18internal sealed class PipelineLoggerProvider(IOptions<PipelineLoggingOptions> options) : ILoggerProvider

Pipelines\PipelineOutputService.cs (1)

34public PipelineOutputService(IOptions<PipelineOptions> options, IConfiguration configuration, IFileSystemService directoryService)

Publishing\ContainerRuntimeResolver.cs (2)

21private readonly IOptions<DcpOptions> _dcpOptions; 28IOptions<DcpOptions> dcpOptions,

Publishing\ManifestPublisher.cs (2)

15IOptions<PublishingOptions> options, 19private readonly IOptions<PublishingOptions> _options = options;

Publishing\ManifestPublishingExtensions.cs (2)

35var pipelineOptions = context.Services.GetRequiredService<IOptions<PipelineOptions>>();

AzureEnvironmentResource.cs (4)

186var azureProvisioningOptions = context.Services.GetRequiredService<IOptions<AzureProvisioningOptions>>(); 245var options = context.Services.GetRequiredService<IOptions<PipelineOptions>>();

AzureProvisioningController.cs (1)

73IOptions<AzureProvisionerOptions> provisionerOptions,

AzureResourcePreparer.cs (1)

22IOptions<AzureProvisioningOptions> options,

Provisioning\Internal\BaseProvisioningContextProvider.cs (1)

22IOptions<AzureProvisionerOptions> options,

Provisioning\Internal\DefaultTokenCredentialProvider.cs (2)

14private readonly IOptions<AzureProvisionerOptions> _options; 22IOptions<AzureProvisionerOptions> options,

Provisioning\Internal\PublishModeProvisioningContextProvider.cs (1)

22IOptions<AzureProvisionerOptions> options,

Provisioning\Internal\RunModeProvisioningContextProvider.cs (1)

23IOptions<AzureProvisionerOptions> options,

AzureContainerAppEnvironmentResource.cs (2)

198var options = services.GetRequiredService<IOptions<AzureProvisioningOptions>>();

AzureContainerAppExtensions.cs (1)

113.GetRequiredService<IOptions<AzureProvisioningOptions>>()

AzureAppServiceEnvironmentResource.cs (2)

201var provisioningOptions = services.GetRequiredService<IOptions<AzureProvisioningOptions>>();

AzureDeployerTests.cs (2)

1494var options = setDefaultProvisioningOptions ? ProvisioningTestHelpers.CreateOptions() : ProvisioningTestHelpers.CreateOptions(null, null, null); 1948var options = ProvisioningTestHelpers.CreateOptions();

AzureEnvironmentResourceExtensionsTests.cs (58)

AzureProvisionerOptionsTests.cs (5)

93var options = Options.Create(azureOptions); 111var options = Options.Create(azureOptions); 135var options = Options.Create(azureOptions); 155var options = Options.Create(azureOptions); 175var options = Options.Create(azureOptions);

DefaultTokenCredentialProviderTests.cs (11)

ProvisioningContextProviderTests.cs (18)

ProvisioningTestHelpers.cs (2)

94public static IOptions<AzureProvisionerOptions> CreateOptions( 108public static IOptions<PublishingOptions> CreatePublishingOptions(

DockerComposeEnvironmentResource.cs (2)

485var options = context.Services.GetRequiredService<IOptions<PipelineOptions>>();

DotnetProjectResource.cs (1)

133var selectedStepName = context.Services.GetRequiredService<IOptions<PipelineOptions>>().Value.Step;

Deployment\HelmDeploymentEngine.cs (2)

636var options = context.Services.GetRequiredService<IOptions<PipelineOptions>>();

DistributedApplicationFactory.cs (1)

171_shutdownTimeout = application.Services.GetService<IOptions<HostOptions>>()?.Value.ShutdownTimeout ?? _shutdownTimeout;

DashboardTestingBuilderTests.cs (3)

107app.Services.GetRequiredService<IOptions<ResourceNotificationServiceOptions>>().Value.DefaultWaitBehavior); 198var dashboardOptions = app.Services.GetRequiredService<IOptions<DashboardOptions>>().Value; 211var dashboardOptions = app.Services.GetRequiredService<IOptions<DashboardOptions>>().Value;

AppHostSmokeTests.cs (2)

92var dcpOptions = host.Services.GetRequiredService<IOptions<DcpOptions>>();

Dashboard\DashboardEventHandlersTests.cs (12)

Dashboard\DashboardOptionsTests.cs (3)

30var dashboardOptions = app.Services.GetRequiredService<IOptions<DashboardOptions>>().Value; 47var dashboardOptions = app.Services.GetRequiredService<IOptions<DashboardOptions>>().Value; 71var dashboardOptions = app.Services.GetRequiredService<IOptions<DashboardOptions>>().Value;

Dashboard\DashboardResourceTests.cs (1)

212var dashboardOptions = app.Services.GetRequiredService<IOptions<DashboardOptions>>().Value;

Dcp\DcpCliArgsTests.cs (6)

57var dcpOptions = app.Services.GetRequiredService<IOptions<DcpOptions>>().Value; 77var dcpOptions = app.Services.GetRequiredService<IOptions<DcpOptions>>().Value; 96var dcpOptions = app.Services.GetRequiredService<IOptions<DcpOptions>>().Value; 115var dcpOptions = app.Services.GetRequiredService<IOptions<DcpOptions>>().Value; 170var dcpOptions = app.Services.GetRequiredService<IOptions<DcpOptions>>().Value; 183var exception = Assert.Throws<InvalidOperationException>(() => app.Services.GetRequiredService<IOptions<DcpOptions>>().Value);

Dcp\DcpHostNotificationTests.cs (15)

Dcp\KubernetesServiceTests.cs (1)

133var dcpOptions = Options.Create(new DcpOptions

DistributedApplicationBuilderTests.cs (6)

64var options = app.Services.GetRequiredService<IOptions<PipelineOptions>>(); 86var pipelineOptions = app.Services.GetRequiredService<IOptions<PipelineOptions>>(); 97var pipelineOptions = app.Services.GetRequiredService<IOptions<PipelineOptions>>();

DistributedApplicationTests.cs (12)

HealthCheckTests.cs (1)

94var registration = app.Services.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations

Lifecycle\TerminalHostFailureDiagnosticServiceTests.cs (1)

234var dcpOptions = Options.Create(new DcpOptions

Pipelines\PipelineLoggerProviderTests.cs (2)

74var options = Options.Create(new PipelineLoggingOptions()); 90var options = Options.Create(new PipelineLoggingOptions());

Publishing\ContainerRuntimeResolverTests.cs (1)

25var dcpOptions = Options.Create(new DcpOptions { ContainerRuntime = configuredRuntime });

Publishing\DeploymentStateManagerTests.cs (4)

404var pipelineOptions = Options.Create(new Hosting.Pipelines.PipelineOptions()); 434var pipelineOptions = Options.Create(new Hosting.Pipelines.PipelineOptions()); 514var pipelineOptions = Options.Create(new Hosting.Pipelines.PipelineOptions()); 541var pipelineOptions = Options.Create(new Hosting.Pipelines.PipelineOptions());

Helpers\JsonDocumentManifestPublisher.cs (1)

19IOptions<PublishingOptions> options,

AspireMicrosoftAzureCosmosExtensionsTests.cs (3)

646var registrations = host.Services.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations; 661var registrations = host.Services.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations; 677var registrations = host.Services.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations;

AspireMicrosoftAzureStackExchangeRedisExtensionsTests.cs (2)

44host.Services.GetRequiredService<IOptions<ConfigurationOptions>>().Value; 68var configurationOptions = host.Services.GetRequiredService<IOptions<ConfigurationOptions>>().Value;

AspireOpenAIExtensions.cs (1)

133serviceProvider.GetRequiredService<IOptions<OpenAIClientOptions>>().Value :

AspireOpenAIExtensionsTests.cs (2)

208var options = host.Services.GetRequiredService<IOptions<OpenAIClientOptions>>().Value; 228var options = host.Services.GetRequiredService<IOptions<OpenAIClientOptions>>().Value;

AspireRedisExtensions.cs (1)

201serviceProvider.GetRequiredService<IOptions<ConfigurationOptions>>().Value :

AspireRedisExtensionsTests.cs (1)

196host.Services.GetRequiredService<IOptions<ConfigurationOptions>>().Value;

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)

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)

29IOptions<AuthenticationOptions> options)

AuthenticationServiceImpl.cs (1)

15IOptions<AuthenticationOptions> options,

DeviceBoundSessionHttpContextExtensions.cs (1)

93.GetRequiredService<IOptions<DeviceBoundSessionSourceSchemes>>().Value;

PostConfigureDeviceBoundSessionAuthenticationOptions.cs (2)

18private readonly IOptions<DeviceBoundSessionSourceSchemes> _sourceSchemes; 20public PostConfigureDeviceBoundSessionAuthenticationOptions(IOptions<DeviceBoundSessionSourceSchemes> sourceSchemes)

PostConfigureDeviceBoundSessionCookieOptions.cs (2)

17private readonly IOptions<DeviceBoundSessionSourceSchemes> _sourceSchemes; 19public PostConfigureDeviceBoundSessionCookieOptions(IOptions<DeviceBoundSessionSourceSchemes> sourceSchemes)

PostConfigureDeviceBoundSessionDerivedCookieOptions.cs (2)

19private readonly IOptions<DeviceBoundSessionSourceSchemes> _sourceSchemes; 23IOptions<DeviceBoundSessionSourceSchemes> sourceSchemes,

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)

DefaultAuthorizationServiceImpl.cs (1)

20IOptions<AuthorizationOptions> options,

PassThroughAuthorizationHandler.cs (1)

28public PassThroughAuthorizationHandler(IOptions<AuthorizationOptions> options)

Routing\RouteTableFactory.cs (1)

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

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

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

Builder\OpaqueRedirection.cs (2)

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

CacheView\MemoryCacheViewStore.cs (1)

17public MemoryCacheViewStore(IOptions<RazorComponentsServiceOptions> options, ILogger<MemoryCacheViewStore> logger)

DependencyInjection\RazorComponentsServiceCollectionExtensions.cs (1)

80var options = sp.GetRequiredService<IOptions<RazorComponentsServiceOptions>>().Value;

FormMapping\HttpContextFormValueMapper.cs (1)

25IOptions<RazorComponentsServiceOptions> options)

Forms\ClientValidationCache.cs (1)

29public ClientValidationCache(IOptions<ValidationOptions> validationOptions)

Forms\DataAnnotationsClientValidationProvider.cs (2)

26IOptions<ValidationOptions> validationOptions, 27IOptions<RazorComponentsServiceOptions> razorComponentsOptions,

Rendering\EndpointHtmlRenderer.cs (1)

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

Rendering\EndpointHtmlRenderer.Streaming.cs (2)

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

TempData\CookieTempDataProvider.cs (1)

29IOptions<RazorComponentsServiceOptions> options,

TempData\TempDataProviderServiceCollectionExtensions.cs (2)

22var options = serviceProvider.GetRequiredService<IOptions<RazorComponentsServiceOptions>>();

EditContextDataAnnotationsExtensions.cs (1)

60_validationOptions = _serviceProvider?.GetService<IOptions<ValidationOptions>>()?.Value;

CircuitJavaScriptInitializationMiddleware.cs (1)

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

Circuits\CircuitFactory.cs (1)

30IOptions<CircuitOptions> options)

Circuits\CircuitPersistenceManager.cs (2)

18IOptions<CircuitOptions> circuitOptions, 202IOptions<CircuitOptions> circuitOptions,

Circuits\CircuitRegistry.cs (1)

48IOptions<CircuitOptions> options,

Circuits\DefaultInMemoryCircuitPersistenceProvider.cs (1)

27IOptions<CircuitOptions> options)

Circuits\HybridCacheCircuitPersistenceProvider.cs (1)

27IOptions<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,

DependencyInjection\ComponentServiceCollectionExtensions.cs (2)

96var circuitOptions = serviceProvider.GetRequiredService<IOptions<CircuitOptions>>();

ProtectedBrowserStorage\ProtectedBrowserStorageJsonSerializerOptions.cs (1)

11public ProtectedBrowserStorageJsonSerializerOptions(IOptions<CircuitOptions> circuitOptions)

Services\DefaultRemoteApplicationPathsProvider.cs (1)

12private readonly IOptions<RemoteAuthenticationOptions<TProviderOptions>> _options;

Services\DeserializedAuthenticationStateProvider.cs (1)

29public DeserializedAuthenticationStateProvider(PersistentComponentState state, IOptions<AuthenticationStateDeserializationOptions> options)

AuthenticationStateSerializer.cs (1)

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

WebAssemblyRazorComponentsBuilderExtensions.cs (1)

39if (sp.GetRequiredService<IOptions<WebAssemblyComponentsServiceOptions>>().Value.UseCultureFromServer)

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)

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;

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,

Latency\RequestLatencyTelemetryMiddleware.cs (2)

37IOptions<RequestLatencyTelemetryOptions> options, 39IOptions<ApplicationMetadata>? appMetdata = null)

Logging\HttpLoggingRedactionInterceptor.cs (1)

39IOptions<LoggingRedactionOptions> options,

Logging\RequestHeadersLogEnricher.cs (1)

32public RequestHeadersLogEnricher(IHttpContextAccessor httpContextAccessor, IOptions<RequestHeadersLogEnricherOptions> options,

Latency\RequestLatencyTelemetryExtensionsTests.cs (2)

62var actualOptions = serviceProvider.GetRequiredService<IOptions<RequestLatencyTelemetryOptions>>();

Logging\HttpLoggingServiceExtensionsTests.cs (6)

47var options = provider.GetRequiredService<IOptions<LoggingRedactionOptions>>().Value; 78var options = provider.GetRequiredService<IOptions<LoggingRedactionOptions>>().Value; 112() => provider.GetRequiredService<IOptions<LoggingRedactionOptions>>().Value); 131() => provider.GetRequiredService<IOptions<LoggingRedactionOptions>>().Value); 145var options = provider.GetRequiredService<IOptions<LoggingRedactionOptions>>().Value; 180var options = provider.GetRequiredService<IOptions<LoggingRedactionOptions>>().Value;

Logging\RequestHeadersEnricherExtensionsTests.cs (1)

65var options = serviceProvider.GetRequiredService<IOptions<RequestHeadersLogEnricherOptions>>().Value;

Logging\TestExtensions.cs (2)

11public static IOptions<RequestHeadersLogEnricherOptions> ToOptions(this RequestHeadersLogEnricherOptions options) 13var mock = new Mock<IOptions<RequestHeadersLogEnricherOptions>>();

Internal\Binding\JsonTranscodingServiceMethodProvider.cs (3)

27IOptions<GrpcServiceOptions> globalOptions, 28IOptions<GrpcServiceOptions<TService>> serviceOptions, 30IOptions<GrpcJsonTranscodingOptions> jsonTranscodingOptions,

HeaderRegistry.cs (1)

21public HeaderRegistry(IServiceProvider provider, IOptions<HeaderParsingOptions> options)

HeaderParsingExtensionsTests.cs (4)

25var options = services.GetRequiredService<IOptions<HeaderParsingOptions>>().Value; 37Assert.Throws<OptionsValidationException>(() => services.GetRequiredService<IOptions<HeaderParsingOptions>>().Value); 47Assert.Throws<OptionsValidationException>(() => services.GetRequiredService<IOptions<HeaderParsingOptions>>().Value); 57var options = services.GetRequiredService<IOptions<HeaderParsingOptions>>().Value;

HeaderParsingFeatureTests.cs (1)

23private readonly IOptions<HeaderParsingOptions> _options;

HeaderRegistryTests.cs (1)

15private readonly IOptions<HeaderParsingOptions> _options;

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;

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)

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

HttpResponseJsonExtensions.cs (1)

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

RequestDelegateFactory.cs (1)

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

HttpResultsHelper.cs (1)

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

ServerSentEventsResult.cs (1)

51var jsonOptions = 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)

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,

_generated\0\GeneratedRouteBuilderExtensions.g.cs (10)

AspNetUserManager.cs (1)

32IOptions<IdentityOptions> optionsAccessor,

DataProtectorTokenProvider.cs (1)

25IOptions<DataProtectionTokenProviderOptions> options,

PasskeyHandler.cs (1)

28public PasskeyHandler(UserManager<TUser> userManager, IOptions<IdentityPasskeyOptions> 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)

54IOptions<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)

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

RequestLocalizationMiddleware.cs (1)

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

DefaultApiDescriptionProvider.cs (2)

47IOptions<MvcOptions> optionsAccessor, 51IOptions<RouteOptions> routeOptions)

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)

29IOptions<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\ControllerActionInvokerCache.cs (1)

30IOptions<MvcOptions> mvcOptions)

Infrastructure\ControllerActionInvokerProvider.cs (2)

32IOptions<MvcOptions> optionsAccessor, 42IOptions<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)

32IOptions<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)

34IOptions<MvcOptions> optionsAccessor, 44IOptions<MvcOptions> optionsAccessor,

CorsApplicationModelProvider.cs (1)

16public CorsApplicationModelProvider(IOptions<MvcOptions> mvcOptions)

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,

XmlDataContractSerializerOutputFormatter.cs (1)

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

XmlSerializerOutputFormatter.cs (1)

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

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)

27IOptions<MvcRazorRuntimeCompilationOptions> options)

RuntimeCompilationFileProvider.cs (1)

17public RuntimeCompilationFileProvider(IOptions<MvcRazorRuntimeCompilationOptions> options)

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)

37IOptions<MvcOptions> mvcOptions, 38IOptions<MvcViewOptions> mvcViewOptions,

Infrastructure\PageRequestDelegateFactory.cs (4)

38IOptions<MvcOptions> mvcOptions, 39IOptions<MvcViewOptions> mvcViewOptions, 52IOptions<MvcOptions> mvcOptions, 53IOptions<MvcViewOptions> mvcViewOptions,

CacheTagHelperMemoryCacheFactory.cs (1)

19public CacheTagHelperMemoryCacheFactory(IOptions<CacheTagHelperOptions> options)

WebApplicationFactory.cs (2)

639var options = serviceProvider.GetService<IOptions<TestServerOptions>>();

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)

13internal 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,

_generated\0\GeneratedRouteBuilderExtensions.g.cs (1)

87var jsonOptions = serviceProvider?.GetService<IOptions<JsonOptions>>()?.Value ?? FallbackJsonOptions;

Services\Schemas\OpenApiSchemaService.cs (1)

32IOptions<JsonOptions> jsonOptions,

DefaultOutputCachePolicyProvider.cs (1)

16public DefaultOutputCachePolicyProvider(IOptions<OutputCacheOptions> options)

OutputCacheKeyProvider.cs (1)

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

OutputCacheMiddleware.cs (2)

42IOptions<OutputCacheOptions> options, 60IOptions<OutputCacheOptions> options,

OutputCacheServiceCollectionExtensions.cs (2)

34var outputCacheOptions = sp.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)

RateLimitingMiddleware.cs (1)

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

DefaultRequestDecompressionProvider.cs (1)

20IOptions<RequestDecompressionOptions> options)

ResponseCachingKeyProvider.cs (1)

25internal 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)

ZstandardCompressionProvider.cs (1)

18public ZstandardCompressionProvider(IOptions<ZstandardCompressionProviderOptions> options)

ZstandardCompressionProviderOptions.cs (1)

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

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)

101var 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)

24IOptions<RouteOptions> routeOptions)

EndpointRoutingMiddleware.cs (1)

39IOptions<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;

RouteEndpointDataSource.cs (1)

244var hasValidationResolvers = builder.ApplicationServices.GetService<IOptions<ValidationOptions>>() is { Value: { } options } && options.Resolvers.Count > 0;

ValidationEndpointFilterFactory.cs (1)

26var options = context.ApplicationServices.GetService<IOptions<ValidationOptions>>()?.Value;

MessagePump.cs (1)

37public MessagePump(IOptions<HttpSysOptions> options, IMemoryPoolFactory<byte> memoryPoolFactory,

WebHostBuilderHttpSysExtensions.cs (1)

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

Core\IISHttpServer.cs (1)

65IOptions<IISServerOptions> options,

IISMiddleware.cs (2)

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

Internal\KestrelServerImpl.cs (2)

37IOptions<KestrelServerOptions> options, 77private 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)

DirectTlsHandshakeLimitSetup.cs (1)

21public DirectTlsHandshakeLimitSetup(IOptions<KestrelServerOptions> serverOptions)

DirectTlsTransportFactory.cs (1)

42IOptions<DirectTlsTransportOptions> options,

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)

27IOptions<SocketTransportOptions> options,

SessionMiddleware.cs (1)

40IOptions<SessionOptions> options)

HubConnectionBuilderHttpExtensions.cs (1)

170public HttpConnectionOptionsDerivedHttpEndPoint(IOptions<HttpConnectionOptions> httpConnectionOptions)

HubConnection.cs (4)

280var options = serviceProvider.GetService<IOptions<HubConnectionOptions>>(); 286_authenticationRefreshOptions = serviceProvider.GetService<IOptions<AuthenticationRefreshOptions>>()?.Value ?? new AuthenticationRefreshOptions(); 2461_hubConnection._serviceProvider.GetService<IOptions<HubConnectionOptions>>()?.Value.StatefulReconnectBufferSize

HubConnectionHandler.cs (2)

56IOptions<HubOptions> globalHubOptions, 57IOptions<HubOptions<THub>> hubOptions,

HubOptionsSetup`T.cs (1)

20public HubOptionsSetup(IOptions<HubOptions> options)

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)

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)

38public TestServer(IServiceProvider services, IOptions<TestServerOptions> optionsAccessor) 49public TestServer(IServiceProvider services, IFeatureCollection featureCollection, IOptions<TestServerOptions> optionsAccessor)

ServiceFakesHostExtensions.cs (1)

45var certificate = host.Services.GetService<IOptions<FakeCertificateOptions>>()?.Value.Certificate;

FakesExtensionsTests.cs (1)

56var certificate = host.Services.GetRequiredService<IOptions<FakeCertificateOptions>>().Value.Certificate;

WebSocketMiddleware.cs (1)

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

AcceptanceTests.cs (2)

75await func(host.Services.GetRequiredService<IOptions<ApplicationMetadata>>().Value, 102await func(host.Services.GetRequiredService<IOptions<ApplicationMetadata>>().Value,

ApplicationMetadataExtensionsTests.cs (2)

135var actualMetadata = provider.GetRequiredService<IOptions<ApplicationMetadata>>().Value; 161var actualMetadata = provider.GetRequiredService<IOptions<ApplicationMetadata>>().Value;

BuildMetadataServiceCollectionExtensionsTests.cs (2)

65.GetRequiredService<IOptions<BuildMetadata>>().Value; 94.GetRequiredService<IOptions<BuildMetadata>>().Value;

ConfigurationBindingQuirkBehaviorTests.cs (2)

29host.Services.GetRequiredService<IOptions<BuildMetadata>>().Value.Should().BeEquivalentTo(defaultMetadata); 49host.Services.GetRequiredService<IOptions<BuildMetadata>>().Value.Should().BeEquivalentTo(metadataWithEmptyStrings);

Internal\DefaultHybridCache.cs (1)

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

BufferReleaseTests.cs (1)

87public TestCache(IOptions<MemoryDistributedCacheOptions> options)

L2Tests.cs (1)

32T IOptions<T>.Value => value;

Options.cs (1)

10public static IOptions<T> Create<T>(T value)

ServiceConstructionTests.cs (6)

MemoryCache.cs (3)

44public MemoryCache(IOptions<MemoryCacheOptions> optionsAccessor) 52public MemoryCache(IOptions<MemoryCacheOptions> optionsAccessor, ILoggerFactory? loggerFactory) 61public MemoryCache(IOptions<MemoryCacheOptions> optionsAccessor, ILoggerFactory? loggerFactory, IMeterFactory? meterFactory)

MemoryCacheOptions.cs (1)

106MemoryCacheOptions 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)

51SqlServerCacheOptions IOptions<SqlServerCacheOptions>.Value

RedisCache.cs (2)

84public RedisCache(IOptions<RedisCacheOptions> optionsAccessor) 94internal RedisCache(IOptions<RedisCacheOptions> optionsAccessor, ILogger logger)

RedisCacheImpl.cs (2)

19public RedisCacheImpl(IOptions<RedisCacheOptions> optionsAccessor, ILogger<RedisCache> logger, IServiceProviderIsService? serviceProviderIsService = null) 25public RedisCacheImpl(IOptions<RedisCacheOptions> optionsAccessor, IServiceProviderIsService? serviceProviderIsService = null)

RedisCacheOptions.cs (1)

45RedisCacheOptions IOptions<RedisCacheOptions>.Value

Classification\DataClassificationTypeConverterTests.cs (2)

50var options = sp.GetRequiredService<IOptions<TestOptions>>();

HmacRedactor.cs (1)

42public HmacRedactor(IOptions<HmacRedactorOptions> options)

RedactorProvider.cs (1)

20public RedactorProvider(IEnumerable<Redactor> redactors, IOptions<RedactorProviderOptions> options)

FakeRedactionServiceCollectionExtensions.cs (2)

32var options = serviceProvider.GetRequiredService<IOptions<FakeRedactorOptions>>().Value; 58var options = serviceProvider.GetRequiredService<IOptions<FakeRedactorOptions>>().Value;

FakeRedactor.cs (2)

39public FakeRedactor(IOptions<FakeRedactorOptions>? options = null, FakeRedactionCollector? collector = null) 41var opt = options ?? Microsoft.Extensions.Options.Options.Create(new FakeRedactorOptions());

AutoActivationHostedService.cs (1)

18public AutoActivationHostedService(IServiceProvider provider, IOptions<AutoActivatorOptions> options)

AutoActivationHostedServiceTests.cs (1)

15var options = Microsoft.Extensions.Options.Options.Create<AutoActivatorOptions>(null!);

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,

TelemetryHealthCheckPublisher.cs (1)

28public TelemetryHealthCheckPublisher(HealthCheckMetrics metrics, ILogger<TelemetryHealthCheckPublisher> logger, IOptions<TelemetryHealthCheckPublisherOptions> options)

ApplicationLifecycleHealthChecksExtensionsTests.cs (1)

56var registrations = serviceProvider.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations;

ManualHealthCheckExtensionsTests.cs (1)

51var registrations = serviceProvider.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations;

TelemetryHealthChecksPublisherTests.cs (1)

94var options = Options.Options.Create(new TelemetryHealthCheckPublisherOptions

ResourceUtilizationHealthCheck.cs (2)

95public ResourceUtilizationHealthCheck(IOptions<ResourceUtilizationHealthCheckOptions> options, IResourceMonitor dataTracker, IOptions<ResourceMonitoringOptions> rmOptions)

ResourceHealthCheckExtensionsTests.cs (4)

90var resourceMonitoringOptions = serviceProvider.GetRequiredService<IOptions<ResourceMonitoringOptions>>().Value; 435ResourceUtilizationHealthCheckOptions options = serviceProvider.GetRequiredService<IOptions<ResourceUtilizationHealthCheckOptions>>().Value; 453ResourceUtilizationHealthCheckOptions options = serviceProvider.GetRequiredService<IOptions<ResourceUtilizationHealthCheckOptions>>().Value; 538var options = Microsoft.Extensions.Options.Options.Create(checkOptions);

ResourceHealthCheckTests.cs (2)

35var options = Microsoft.Extensions.Options.Options.Create(checkOptions); 69Mock.Of<IOptions<ResourceUtilizationHealthCheckOptions>>(),

TcpEndpointProbesExtensionsTests.cs (4)

56var configurations = host.Services.GetServices<IOptions<TcpEndpointProbesOptions>>(); 59var config = Assert.Single(configurations); 119var configurations = host.Services.GetServices<IOptions<TcpEndpointProbesOptions>>(); 122var configuration = Assert.Single(configurations);

ResourceMonitorService.cs (2)

57IOptions<ResourceMonitoringOptions> options, 66IOptions<ResourceMonitoringOptions> options,

Windows\Disk\WindowsDiskMetrics.cs (1)

34IOptions<ResourceMonitoringOptions> options)

Windows\Network\WindowsTcpStateInfo.cs (1)

28public WindowsTcpStateInfo(IOptions<ResourceMonitoringOptions> options)

Windows\WindowsContainerSnapshotProvider.cs (1)

61IOptions<ResourceMonitoringOptions> options,

Windows\WindowsSnapshotProvider.cs (1)

43public WindowsSnapshotProvider(ILogger<WindowsSnapshotProvider>? logger, IMeterFactory meterFactory, IOptions<ResourceMonitoringOptions> options)

Linux\AcceptanceTest.cs (1)

91var options = Microsoft.Extensions.Options.Options.Create(new ResourceMonitoringOptions

ResourceMonitoringExtensionsTests.cs (6)

115var options = host.Services.GetService<IOptions<ResourceMonitoringOptions>>(); 148var options = host.Services.GetService<IOptions<ResourceMonitoringOptions>>(); 190var options = host.Services.GetService<IOptions<ResourceMonitoringOptions>>();

Windows\WindowsSnapshotProviderTests.cs (1)

28private readonly IOptions<ResourceMonitoringOptions> _options;

Logging\FakeLogCollector.cs (1)

28public FakeLogCollector(IOptions<FakeLogCollectorOptions> options)

HostBuilder.cs (1)

326appServices.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)

42IOptions<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)

Latency\Internal\HttpLatencyTelemetryHandler.cs (2)

29IOptions<HttpClientLatencyTelemetryOptions> options, IOptions<ApplicationMetadata> appMetadata, HttpLatencyMediator latencyTelemetryMediator)

Latency\HttpClientLatencyTelemetryExtensionsTest.cs (3)

49var options = sp.GetRequiredService<IOptions<HttpClientLatencyTelemetryOptions>>().Value; 83var options = sp.GetRequiredService<IOptions<HttpClientLatencyTelemetryOptions>>().Value; 103var options = sp.GetRequiredService<IOptions<HttpClientLatencyTelemetryOptions>>().Value;

Latency\Internal\HttpLatencyMediatorTests.cs (2)

54var sop = new Mock<IOptions<ApplicationMetadata>>(); 56var hop = new Mock<IOptions<HttpClientLatencyTelemetryOptions>>();

Latency\Internal\HttpLatencyTelemetryHandlerTest.cs (6)

26var sop = new Mock<IOptions<ApplicationMetadata>>(); 28var hop = new Mock<IOptions<HttpClientLatencyTelemetryOptions>>(); 48var sop = new Mock<IOptions<ApplicationMetadata>>(); 50var hop = new Mock<IOptions<HttpClientLatencyTelemetryOptions>>(); 91var sop = new Mock<IOptions<ApplicationMetadata>>(); 93var hop = new Mock<IOptions<HttpClientLatencyTelemetryOptions>>();

Logging\AcceptanceTests.cs (1)

561var optionsSixth = provider.GetRequiredService<IOptions<LoggingOptions>>().Value;

Logging\HttpClientLoggingExtensionsTest.cs (4)

144var options = provider.GetRequiredService<IOptions<LoggingOptions>>().Value; 505var options = provider.GetRequiredService<IOptions<LoggingOptions>>().Value; 602.GetRequiredService<IOptions<LoggingOptions>>().Value; 629var options = provider.GetRequiredService<IOptions<LoggingOptions>>().Value;

Resilience\HttpClientBuilderExtensionsTests.Resilience.cs (1)

175var registryOptions = serviceProvider.GetRequiredService<IOptions<ResiliencePipelineRegistryOptions<HttpKey>>>().Value;

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)

72IOptions<IdentityOptions> optionsAccessor,

ResourceManagerStringLocalizerFactory.cs (2)

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

LoggerFactory.cs (2)

71public LoggerFactory(IEnumerable<ILoggerProvider> providers, IOptionsMonitor<LoggerFilterOptions> filterOption, IOptions<LoggerFactoryOptions>? options) : this(providers, filterOption, options, null) 82public 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)

ModelLoaders\FileModelLoader.cs (1)

28public FileModelLoader(IOptions<MLOptions> contextOptions, ILogger<FileModelLoader> logger)

ModelLoaders\UriModelLoader.cs (1)

35public UriModelLoader(IOptions<MLOptions> contextOptions, ILogger<UriModelLoader> logger)

PoolLoader.cs (2)

34var contextOptions = sp.GetRequiredService<IOptions<MLOptions>>();

PredictionEnginePool.cs (1)

30IOptions<MLOptions> mlContextOptions,

FileLoaderTests.cs (2)

51var context = sp.GetRequiredService<IOptions<MLOptions>>().Value.MLContext; 82public FileLoaderMock(IOptions<MLOptions> contextOptions, ILogger<FileModelLoader> logger)

UriLoaderTests.cs (1)

85public UriLoaderMock(IOptions<MLOptions> contextOptions,

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)

OptionsBuilderExtensions.cs (3)

24/// seeds the built-in <see cref="IOptions{TOptions}"/> and <see cref="IOptionsMonitor{TOptions}"/> instances 33/// validation requires the built-in <see cref="IOptions{TOptions}"/> implementation; startup throws 70.Configure<IOptions<TOptions>, IOptionsMonitor<TOptions>, IOptionsFactory<TOptions>, IOptionsMonitorCache<TOptions>>((vo, options, monitor, factory, sharedCache) =>

OptionsManager.cs (1)

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

OptionsServiceCollectionExtensions.cs (1)

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

ValidateOnStart.cs (1)

19public StartupValidator(IOptions<StartupValidatorOptions> validators)

Resilience\ResilienceServiceCollectionExtensionsTests.cs (2)

38var enrichers = _services.BuildServiceProvider().GetRequiredService<IOptions<TelemetryOptions>>().Value.MeteringEnrichers; 48var enrichers = services.BuildServiceProvider().GetRequiredService<IOptions<TelemetryOptions>>().Value.MeteringEnrichers;

Configuration\ConfigurationServiceEndpointProvider.cs (3)

22private readonly IOptions<ConfigurationServiceEndpointProviderOptions> _options; 36IOptions<ConfigurationServiceEndpointProviderOptions> options, 37IOptions<ServiceDiscoveryOptions> serviceDiscoveryOptions)

Configuration\ConfigurationServiceEndpointProviderFactory.cs (2)

16IOptions<ConfigurationServiceEndpointProviderOptions> options, 17IOptions<ServiceDiscoveryOptions> serviceDiscoveryOptions,

Http\ResolvingHttpClientHandler.cs (1)

11internal sealed class ResolvingHttpClientHandler(HttpServiceEndpointResolver resolver, IOptions<ServiceDiscoveryOptions> options) : HttpClientHandler

Http\ResolvingHttpDelegatingHandler.cs (2)

22public ResolvingHttpDelegatingHandler(HttpServiceEndpointResolver resolver, IOptions<ServiceDiscoveryOptions> options) 34public ResolvingHttpDelegatingHandler(HttpServiceEndpointResolver resolver, IOptions<ServiceDiscoveryOptions> options, HttpMessageHandler innerHandler) : base(innerHandler)

Http\ServiceDiscoveryHttpMessageHandlerFactory.cs (1)

12IOptions<ServiceDiscoveryOptions> options) : IServiceDiscoveryHttpMessageHandlerFactory

ServiceDiscoveryHttpClientBuilderExtensions.cs (2)

36var options = services.GetRequiredService<IOptions<ServiceDiscoveryOptions>>();

ServiceEndpointWatcher.cs (1)

21IOptions<ServiceDiscoveryOptions> options) : IAsyncDisposable

ServiceEndpointWatcherFactory.cs (2)

16IOptions<ServiceDiscoveryOptions> options, 24private readonly IOptions<ServiceDiscoveryOptions> _options = options;

Resolver\DnsResolver.cs (1)

29public DnsResolver(TimeProvider timeProvider, ILogger<DnsResolver> logger, IOptions<DnsResolverOptions> options)

ServiceDiscoveryDnsServiceCollectionExtensionsTests.cs (8)

48var options = serviceProvider.GetRequiredService<IOptions<DnsResolverOptions>>(); 61var options = serviceProvider.GetRequiredService<IOptions<DnsResolverOptions>>(); 74var options = serviceProvider.GetRequiredService<IOptions<DnsResolverOptions>>(); 87var options = serviceProvider.GetRequiredService<IOptions<DnsResolverOptions>>();

ServiceDiscoveryDestinationResolver.cs (1)

19internal sealed class ServiceDiscoveryDestinationResolver(ServiceEndpointResolver resolver, IOptions<ServiceDiscoveryOptions> options) : IDestinationResolver

YarpServiceDiscoveryTests.cs (1)

27serviceProvider.GetRequiredService<IOptions<ServiceDiscoveryOptions>>());

Enrichment\ApplicationLogEnricher.cs (2)

16IOptions<ApplicationLogEnricherOptions> options, 17IOptions<ApplicationMetadata> metadata)

Enrichment\ProcessLogEnricher.cs (1)

20public ProcessLogEnricher(IOptions<ProcessLogEnricherOptions> options)

Enrichment\StaticProcessLogEnricher.cs (1)

18public StaticProcessLogEnricher(IOptions<ProcessLogEnricherOptions> options)

Latency\Internal\LatencyConsoleExporter.cs (1)

34public LatencyConsoleExporter(IOptions<LatencyConsoleOptions> options)

Latency\Internal\LatencyContextRegistrySet.cs (2)

31public LatencyContextRegistrySet(IOptions<LatencyContextOptions> latencyContextOptions, 32IOptions<LatencyContextRegistrationOptions>? registrationOptions = null)

Logging\ExtendedLoggerFactory.cs (1)

46IOptions<LoggerFactoryOptions>? factoryOptions = null,

Latency\LatencyRegistryExtensionsTests.cs (2)

45var option = serviceProvider.GetService<IOptions<LatencyContextRegistrationOptions>>();

Enrichment\ApplicationEnricherExtensionsTests.cs (2)

62var options = host.Services.GetRequiredService<IOptions<ApplicationLogEnricherOptions>>().Value; 88var options = host.Services.GetRequiredService<IOptions<ApplicationLogEnricherOptions>>().Value;

Enrichment\ApplicationLogEnricherTests.cs (5)

34var options = new ApplicationLogEnricherOptions 39var optionsNull = new Mock<IOptions<ApplicationLogEnricherOptions>>(); 40optionsNull.Setup(o => o.Value).Returns<IOptions<ApplicationLogEnricherOptions>>(null!); 42var applicationOptionsNull = new Mock<IOptions<ApplicationMetadata>>(); 43applicationOptionsNull.Setup(o => o.Value).Returns<IOptions<ApplicationMetadata>>(null!);

Enrichment\Internals\TestExtensions.cs (2)

11public static IOptions<T> ToOptions<T>(this T options) 14var mock = new Mock<IOptions<T>>();

Enrichment\ProcessEnricherExtensionsTests.cs (2)

63var options = host.Services.GetRequiredService<IOptions<ProcessLogEnricherOptions>>().Value; 86var options = host.Services.GetRequiredService<IOptions<ProcessLogEnricherOptions>>().Value;

Enrichment\ProcessLogEnricherTests.cs (2)

23var optionsNull = new Mock<IOptions<ProcessLogEnricherOptions>>(); 24optionsNull.Setup(o => o.Value).Returns<IOptions<ProcessLogEnricherOptions>>(null!);

Enrichment\ServiceEnricherExtensionsTests.cs (2)

63var options = host.Services.GetRequiredService<IOptions<ApplicationLogEnricherOptions>>().Value; 89var options = host.Services.GetRequiredService<IOptions<ApplicationLogEnricherOptions>>().Value;

Latency\Internal\LatencyConsoleExporterTests.cs (4)

75var options = Options.Options.Create(new LatencyConsoleOptions 97var options = Options.Options.Create(new LatencyConsoleOptions 119var options = Options.Options.Create(new LatencyConsoleOptions 141var options = Options.Options.Create(new LatencyConsoleOptions

Latency\Internal\LatencyContextPoolTests.cs (2)

98var option = MockLatencyContextRegistrationOptions.GetLatencyContextRegistrationOptions( 101var lco = new Mock<IOptions<LatencyContextOptions>>();

Latency\Internal\LatencyContextProviderTests.cs (3)

98var lco = new Mock<IOptions<LatencyContextOptions>>(); 108var lco = new Mock<IOptions<LatencyContextOptions>>(); 115private static IOptions<LatencyContextRegistrationOptions> GetRegistrationOption()

Latency\Internal\LatencyContextRegistrySetTests.cs (3)

17var lco = new Mock<IOptions<LatencyContextOptions>>(); 84var lco = new Mock<IOptions<LatencyContextOptions>>(); 87var o = MockLatencyContextRegistrationOptions.GetLatencyContextRegistrationOptions(checkpoints, measures, tags);

Latency\Internal\LatencyContextTests.cs (2)

295var option = MockLatencyContextRegistrationOptions.GetLatencyContextRegistrationOptions( 297var lco = new Mock<IOptions<LatencyContextOptions>>();

Latency\Internal\LatencyContextTokenIssuerTests.cs (2)

64var option = MockLatencyContextRegistrationOptions.GetLatencyContextRegistrationOptions( 66var lco = new Mock<IOptions<LatencyContextOptions>>();

Latency\Internal\MockLatencyContextRegistrationOptions.cs (2)

11public static IOptions<LatencyContextRegistrationOptions> GetLatencyContextRegistrationOptions( 23var lcro = new Mock<IOptions<LatencyContextRegistrationOptions>>();

Latency\LatencyConsoleExtensionsTests.cs (2)

62var actualOptions = provider.GetRequiredService<IOptions<LatencyConsoleOptions>>();

Latency\LatencyContextExtensionTests.cs (2)

98var actualOptions = provider.GetRequiredService<IOptions<LatencyContextOptions>>();

EncoderServiceCollectionExtensions.cs (1)

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

BuildMetadataHostBuilderExtensionsTests.cs (4)

23var buildMetadata = host.Services.GetRequiredService<IOptions<Extensions.AmbientMetadata.BuildMetadata>>(); 39var buildMetadata = host.Services.GetRequiredService<IOptions<Extensions.AmbientMetadata.BuildMetadata>>();