IOptions

1 interface inheriting from IOptions

Microsoft.Extensions.Options (1)

IOptionsSnapshot.cs (1)

21IOptions<TOptions>

13 implementations of IOptions

Aspire.Hosting.Azure.Tests (1)

DefaultTokenCredentialProviderTests.cs (1)

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

Microsoft.AspNetCore.Mvc.Core (1)

ModelBinding\EmptyModelMetadataProvider.cs (1)

26private sealed class OptionsAccessor : IOptions<MvcOptions>

Microsoft.AspNetCore.ResponseCompression (3)

BrotliCompressionProviderOptions.cs (1)

12public class BrotliCompressionProviderOptions : IOptions<BrotliCompressionProviderOptions>

GzipCompressionProviderOptions.cs (1)

12public class GzipCompressionProviderOptions : IOptions<GzipCompressionProviderOptions>

ZstandardCompressionProviderOptions.cs (1)

12public class ZstandardCompressionProviderOptions : IOptions<ZstandardCompressionProviderOptions>

Microsoft.Extensions.Caching.Hybrid.Tests (2)

L2Tests.cs (1)

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

Options.cs (1)

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

Microsoft.Extensions.Caching.Memory (1)

MemoryCacheOptions.cs (1)

14public class MemoryCacheOptions : IOptions<MemoryCacheOptions>

Microsoft.Extensions.Caching.SqlServer (1)

SqlServerCacheOptions.cs (1)

13public class SqlServerCacheOptions : IOptions<SqlServerCacheOptions>

Microsoft.Extensions.Caching.StackExchangeRedis (1)

RedisCacheOptions.cs (1)

16public class RedisCacheOptions : IOptions<RedisCacheOptions>

Microsoft.Extensions.Options (3)

OptionsManager.cs (1)

14IOptions<TOptions>,

OptionsWrapper.cs (1)

13IOptions<TOptions>

UnnamedOptionsManager.cs (1)

10IOptions<TOptions>

962 references to IOptions

Aspire.Azure.Messaging.EventHubs.Tests (1)

ConformanceTestsBase.cs (1)

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

Aspire.Dashboard (19)

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

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

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

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

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

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

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

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

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

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

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

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

DashboardWebApplication.cs (2)

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

Model\BrowserStorage\LocalBrowserStorage.cs (1)

22IOptions<CircuitOptions> circuitOptions) : base(protectedLocalStorage, logger)

Model\MetricPinStore.cs (1)

27public MetricPinStore(IOptions<DashboardOptions> options, ILogger<MetricPinStore> logger)

Model\ResourceOrderStore.cs (1)

26public ResourceOrderStore(IOptions<DashboardOptions> options, ILogger<ResourceOrderStore> logger)

Model\ResourceTagStore.cs (1)

31public ResourceTagStore(IOptions<DashboardOptions> options, ILogger<ResourceTagStore> logger)

Otlp\Storage\SqliteTelemetryRepository.cs (1)

85IOptions<DashboardOptions> dashboardOptions,

ServiceClient\DashboardClient.cs (1)

99IOptions<DashboardOptions> dashboardOptions,

ServiceClient\DashboardRunStore.cs (2)

98public DashboardRunStore(IOptions<DashboardOptions> options, ILogger<DashboardRunStore> logger, TimeProvider timeProvider) 104IOptions<DashboardOptions> options,

ServiceClient\RepositoryFactory.cs (2)

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

ServiceClient\SqliteResourceRepository.cs (1)

42IOptions<DashboardOptions> dashboardOptions)

Aspire.Dashboard.Components.Tests (7)

Pages\StructuredLogsTests.cs (1)

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

Pages\TracesTests.cs (1)

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

Shared\FluentUISetupHelpers.cs (5)

168var options = context.Services.GetRequiredService<IOptions<DashboardOptions>>(); 218var options = services.GetRequiredService<IOptions<DashboardOptions>>(); 272context.Services.AddSingleton<IOptions<DashboardOptions>>(Options.Create(new DashboardOptions()));

Aspire.Dashboard.Tests (52)

DashboardOptionsTests.cs (1)

423var options = app.Services.GetRequiredService<IOptions<AntiforgeryOptions>>().Value;

Integration\StartupTests.cs (5)

91var options = app.Services.GetRequiredService<IOptions<Microsoft.AspNetCore.Http.Json.JsonOptions>>().Value.SerializerOptions; 670var options = app.Services.GetRequiredService<IOptions<LoggerFilterOptions>>(); 712var options = app.Services.GetRequiredService<IOptions<LoggerFilterOptions>>();

Model\DashboardDataSourceTests.cs (39)

Shared\SqliteRepositoryTestHelpers.cs (3)

70IOptions<DashboardOptions>? dashboardOptions = null, 104IOptions<DashboardOptions>? dashboardOptions = null, 136IOptions<DashboardOptions>? dashboardOptions,

TelemetryRepositoryTests\HistogramTests.cs (2)

649var options = Options.Create(new DashboardOptions { TelemetryLimits = new TelemetryLimitOptions { MaxMetricsCount = 120 } }); 697var options = Options.Create(new DashboardOptions { TelemetryLimits = new TelemetryLimitOptions { MaxMetricsCount = 3 } });

TelemetryRepositoryTests\SqliteTelemetryPersistenceTests.cs (1)

456var options = Options.Create(new DashboardOptions

TelemetryRepositoryTests\TelemetryRepositoryTestBase.cs (1)

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

Aspire.Hosting (52)

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)

32IOptions<DashboardOptions> dashboardOptions, 228var 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)

24private readonly IOptions<DcpOptions> _options; 36IOptions<DcpOptions> options,

Dcp\ContainerNetworkEndpointProvisioner.cs (2)

59private readonly IOptions<DcpOptions> _options; 74IOptions<DcpOptions> options,

Dcp\DcpDependencyCheck.cs (1)

27public DcpDependencyCheck(IOptions<DcpOptions> dcpOptions)

Dcp\DcpExecutor.cs (2)

46private readonly IOptions<DcpOptions> _options; 83IOptions<DcpOptions> options,

Dcp\DcpHost.cs (1)

49IOptions<DcpOptions> dcpOptions,

Dcp\DcpNameGenerator.cs (2)

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

Dcp\KubernetesService.cs (1)

85internal sealed class KubernetesService(ILogger<KubernetesService> logger, IOptions<DcpOptions> dcpOptions, Locations locations, IConfiguration configuration, TimeProvider timeProvider) : 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)

666_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)

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

Pipelines\Internal\FileDeploymentStateManager.cs (1)

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

Pipelines\PipelineLoggerProvider.cs (1)

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

Pipelines\PipelineOutputService.cs (1)

30public 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)

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

Aspire.Hosting.Azure (12)

AzureEnvironmentResource.cs (4)

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

AzureProvisioningController.cs (1)

72IOptions<AzureProvisionerOptions> provisionerOptions,

AzureResourcePreparer.cs (1)

21IOptions<AzureProvisioningOptions> options,

Provisioning\BicepUtilities.cs (1)

63parameterValue = executionContext.Services.GetRequiredService<IOptions<AzureProvisionerOptions>>().Value.TenantResourceSuffix ?? string.Empty;

Provisioning\Internal\BaseProvisioningContextProvider.cs (1)

20IOptions<AzureProvisionerOptions> options,

Provisioning\Internal\DefaultTokenCredentialProvider.cs (2)

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

Provisioning\Internal\PublishModeProvisioningContextProvider.cs (1)

20IOptions<AzureProvisionerOptions> options,

Provisioning\Internal\RunModeProvisioningContextProvider.cs (1)

22IOptions<AzureProvisionerOptions> options,

Aspire.Hosting.Azure.AppContainers (3)

AzureContainerAppEnvironmentResource.cs (2)

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

AzureContainerAppExtensions.cs (1)

111.GetRequiredService<IOptions<AzureProvisioningOptions>>()

Aspire.Hosting.Azure.AppService (2)

AzureAppServiceEnvironmentResource.cs (2)

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

Aspire.Hosting.Azure.EntraId.Tests (8)

EntraIdApiProvisioningTests.cs (1)

729var options = app.Services.GetRequiredService<IOptions<AzureProvisioningOptions>>().Value;

EntraIdProvisioningTests.cs (6)

622var options = app.Services.GetRequiredService<IOptions<AzureProvisioningOptions>>().Value; 649app.Services.GetRequiredService<IOptions<AzureProvisioningOptions>>().Value, 674app.Services.GetRequiredService<IOptions<AzureProvisioningOptions>>().Value, 707app.Services.GetRequiredService<IOptions<AzureProvisioningOptions>>().Value, 738app.Services.GetRequiredService<IOptions<AzureProvisioningOptions>>().Value, 775var options = app.Services.GetRequiredService<IOptions<AzureProvisioningOptions>>().Value;

EntraIdStarterScenarioPublishTests.cs (1)

62app.Services.GetRequiredService<IOptions<AzureProvisioningOptions>>().Value,

Aspire.Hosting.Azure.Kubernetes (1)

AzureKubernetesEnvironmentResource.cs (1)

117var targetStep = context.Services.GetRequiredService<IOptions<PipelineOptions>>().Value.Step;

Aspire.Hosting.Azure.Tests (110)

AzureConnectorNamespaceTests.cs (2)

33var options = app.Services.GetRequiredService<IOptions<AzureProvisioningOptions>>();

AzureDeployerTests.cs (3)

125OnRequest = (_, _) => requestedTenants.Add(sp.GetRequiredService<IOptions<AzureProvisionerOptions>>().Value.TenantId) 1742var options = setDefaultProvisioningOptions ? ProvisioningTestHelpers.CreateOptions() : ProvisioningTestHelpers.CreateOptions(null, null, null); 2203var options = ProvisioningTestHelpers.CreateOptions();

AzureEnvironmentResourceExtensionsTests.cs (61)

AzureEnvironmentResourceTests.cs (1)

388var provisioningOptions = app.Services.GetRequiredService<IOptions<AzureProvisioningOptions>>().Value;

AzureProvisionerOptionsTests.cs (5)

91var options = Options.Create(azureOptions); 109var options = Options.Create(azureOptions); 133var options = Options.Create(azureOptions); 153var options = Options.Create(azureOptions); 173var options = Options.Create(azureOptions);

AzureWebPubSubEmulatorTests.cs (1)

145var registration = Assert.Single(app.Services.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations,

DefaultTokenCredentialProviderTests.cs (11)

ProvisioningContextProviderTests.cs (24)

ProvisioningTestHelpers.cs (2)

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

Aspire.Hosting.Docker (2)

DockerComposeEnvironmentResource.cs (2)

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

Aspire.Hosting.Kafka.Tests (2)

AddKafkaTests.cs (2)

26var registration = Assert.Single(app.Services.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations); 50var registrations = app.Services.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations;

Aspire.Hosting.Kubernetes (2)

Deployment\HelmDeploymentEngine.cs (2)

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

Aspire.Hosting.SqlServer.Tests (1)

AddSqlServerTests.cs (1)

314var registrations = app.Services.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations;

Aspire.Hosting.Testing (1)

DistributedApplicationFactory.cs (1)

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

Aspire.Hosting.Testing.Tests (3)

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;

Aspire.Hosting.Tests (70)

AppHostSmokeTests.cs (2)

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

Dashboard\DashboardEventHandlersTests.cs (13)

Dashboard\DashboardOptionsTests.cs (3)

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

Dashboard\DashboardResourceTests.cs (1)

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

Dcp\DcpCliArgsTests.cs (7)

68var dcpOptions = app.Services.GetRequiredService<IOptions<DcpOptions>>().Value; 84var dcpOptions = app.Services.GetRequiredService<IOptions<DcpOptions>>().Value; 101var dcpOptions = app.Services.GetRequiredService<IOptions<DcpOptions>>().Value; 120var dcpOptions = app.Services.GetRequiredService<IOptions<DcpOptions>>().Value; 139var dcpOptions = app.Services.GetRequiredService<IOptions<DcpOptions>>().Value; 194var dcpOptions = app.Services.GetRequiredService<IOptions<DcpOptions>>().Value; 207var exception = Assert.Throws<InvalidOperationException>(() => app.Services.GetRequiredService<IOptions<DcpOptions>>().Value);

Dcp\DcpHostNotificationTests.cs (15)

Dcp\KubernetesServiceTests.cs (1)

2290var dcpOptions = Options.Create(new DcpOptions

DistributedApplicationBuilderTests.cs (7)

68var options = app.Services.GetRequiredService<IOptions<PipelineOptions>>(); 90var pipelineOptions = app.Services.GetRequiredService<IOptions<PipelineOptions>>(); 101var pipelineOptions = app.Services.GetRequiredService<IOptions<PipelineOptions>>(); 186var filterOptions = app.Services.GetRequiredService<IOptions<LoggerFilterOptions>>().Value;

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)

72var options = Options.Create(new PipelineLoggingOptions()); 88var options = Options.Create(new PipelineLoggingOptions());

Publishing\ContainerRuntimeResolverTests.cs (1)

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

Publishing\DeploymentStateManagerTests.cs (4)

446var pipelineOptions = Options.Create(new Hosting.Pipelines.PipelineOptions()); 1225var pipelineOptions = Options.Create(new Hosting.Pipelines.PipelineOptions()); 1305var pipelineOptions = Options.Create(new Hosting.Pipelines.PipelineOptions()); 1332var pipelineOptions = Options.Create(new Hosting.Pipelines.PipelineOptions());

Aspire.Hosting.TestUtilities (1)

Helpers\JsonDocumentManifestPublisher.cs (1)

17IOptions<PublishingOptions> options,

Aspire.Microsoft.Azure.Cosmos.Tests (3)

AspireMicrosoftAzureCosmosExtensionsTests.cs (3)

748var registrations = host.Services.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations; 763var registrations = host.Services.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations; 779var registrations = host.Services.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value.Registrations;

Aspire.Microsoft.Azure.StackExchangeRedis.Tests (2)

AspireMicrosoftAzureStackExchangeRedisExtensionsTests.cs (2)

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

Aspire.OpenAI (1)

AspireOpenAIExtensions.cs (1)

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

Aspire.OpenAI.Tests (2)

AspireOpenAIExtensionsTests.cs (2)

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

Aspire.StackExchange.Redis (1)

AspireRedisExtensions.cs (1)

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

Aspire.StackExchange.Redis.Tests (1)

AspireRedisExtensionsTests.cs (1)

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

Microsoft.AspNetCore.Antiforgery (3)

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)

Microsoft.AspNetCore.Authentication (1)

AuthenticationBuilder.cs (1)

117public EnsureSignInScheme(IOptions<AuthenticationOptions> authOptions)

Microsoft.AspNetCore.Authentication.BearerToken (1)

BearerTokenHandler.cs (1)

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

Microsoft.AspNetCore.Authentication.Certificate (2)

CertificateValidationCache.cs (2)

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

Microsoft.AspNetCore.Authentication.Core (4)

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,

Microsoft.AspNetCore.Authorization (4)

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)

Microsoft.AspNetCore.Components (2)

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)

Microsoft.AspNetCore.Components.Endpoints (14)

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>>();

Microsoft.AspNetCore.Components.Forms (1)

EditContextDataAnnotationsExtensions.cs (1)

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

Microsoft.AspNetCore.Components.Server (13)

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)

Microsoft.AspNetCore.Components.WebAssembly.Authentication (2)

Services\DefaultRemoteApplicationPathsProvider.cs (1)

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

Services\DeserializedAuthenticationStateProvider.cs (1)

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

Microsoft.AspNetCore.Components.WebAssembly.Server (2)

AuthenticationStateSerializer.cs (1)

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

WebAssemblyRazorComponentsBuilderExtensions.cs (1)

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

Microsoft.AspNetCore.CookiePolicy (2)

CookiePolicyMiddleware.cs (2)

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

Microsoft.AspNetCore.Cors (2)

Infrastructure\CorsService.cs (1)

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

Infrastructure\DefaultCorsPolicyProvider.cs (1)

19public DefaultCorsPolicyProvider(IOptions<CorsOptions> options)

Microsoft.AspNetCore.DataProtection (13)

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;

Microsoft.AspNetCore.Diagnostics (10)

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)

Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore (4)

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)

Microsoft.AspNetCore.Diagnostics.HealthChecks (4)

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,

Microsoft.AspNetCore.Diagnostics.Middleware (4)

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,

Microsoft.AspNetCore.Diagnostics.Middleware.Tests (11)

Latency\RequestLatencyTelemetryExtensionsTests.cs (2)

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

Logging\HttpLoggingServiceExtensionsTests.cs (6)

49var options = provider.GetRequiredService<IOptions<LoggingRedactionOptions>>().Value; 80var options = provider.GetRequiredService<IOptions<LoggingRedactionOptions>>().Value; 114() => provider.GetRequiredService<IOptions<LoggingRedactionOptions>>().Value); 133() => provider.GetRequiredService<IOptions<LoggingRedactionOptions>>().Value); 147var options = provider.GetRequiredService<IOptions<LoggingRedactionOptions>>().Value; 182var 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>>();

Microsoft.AspNetCore.Grpc.JsonTranscoding (3)

Internal\Binding\JsonTranscodingServiceMethodProvider.cs (3)

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

Microsoft.AspNetCore.HeaderParsing (1)

HeaderRegistry.cs (1)

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

Microsoft.AspNetCore.HeaderParsing.Tests (6)

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;

Microsoft.AspNetCore.HeaderPropagation (4)

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)

Microsoft.AspNetCore.Hosting (2)

GenericHost\GenericWebHostService.cs (1)

19public GenericWebHostService(IOptions<GenericWebHostServiceOptions> options,

Http\DefaultHttpContextFactory.cs (1)

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

Microsoft.AspNetCore.Http.Connections (1)

Internal\HttpConnectionManager.cs (1)

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

Microsoft.AspNetCore.Http.Connections.Client (1)

HttpConnectionFactory.cs (1)

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

Microsoft.AspNetCore.Http.Extensions (5)

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;

Microsoft.AspNetCore.Http.Results (2)

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();

Microsoft.AspNetCore.HttpOverrides (3)

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)

Microsoft.AspNetCore.HttpsPolicy (4)

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,

Microsoft.AspNetCore.Identity (28)

AspNetUserManager.cs (1)

32IOptions<IdentityOptions> optionsAccessor,

DataProtectorTokenProvider.cs (1)

25IOptions<DataProtectionTokenProviderOptions> options,

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\GeneratedRouteBuilderExtensions.g.cs (18)

PasskeyEndpointsEndpointRouteBuilderExtensions.cs (2)

98var options = services.GetRequiredService<IOptions<PasskeyEndpointsOptions>>().Value; 107var serverDomain = services.GetRequiredService<IOptions<IdentityPasskeyOptions>>().Value.ServerDomain;

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)

Microsoft.AspNetCore.Identity.EntityFrameworkCore (1)

IdentityUserContext.cs (1)

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

Microsoft.AspNetCore.Localization (1)

RequestLocalizationMiddleware.cs (1)

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

Microsoft.AspNetCore.Mvc.ApiExplorer (2)

DefaultApiDescriptionProvider.cs (2)

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

Microsoft.AspNetCore.Mvc.Core (40)

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,

Microsoft.AspNetCore.Mvc.Cors (1)

CorsApplicationModelProvider.cs (1)

16public CorsApplicationModelProvider(IOptions<MvcOptions> mvcOptions)

Microsoft.AspNetCore.Mvc.DataAnnotations (10)

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,

Microsoft.AspNetCore.Mvc.Formatters.Xml (2)

XmlDataContractSerializerOutputFormatter.cs (1)

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

XmlSerializerOutputFormatter.cs (1)

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

Microsoft.AspNetCore.Mvc.NewtonsoftJson (5)

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,

Microsoft.AspNetCore.Mvc.Razor (1)

RazorViewEngine.cs (1)

53IOptions<RazorViewEngineOptions> optionsAccessor,

Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation (4)

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)

Microsoft.AspNetCore.Mvc.RazorPages (18)

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,

Microsoft.AspNetCore.Mvc.TagHelpers (1)

CacheTagHelperMemoryCacheFactory.cs (1)

19public CacheTagHelperMemoryCacheFactory(IOptions<CacheTagHelperOptions> options)

Microsoft.AspNetCore.Mvc.Testing (2)

WebApplicationFactory.cs (2)

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

Microsoft.AspNetCore.Mvc.ViewFeatures (19)

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,

Microsoft.AspNetCore.OpenApi (2)

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\GeneratedRouteBuilderExtensions.g.cs (1)

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

Services\Schemas\OpenApiSchemaService.cs (1)

32IOptions<JsonOptions> jsonOptions,

Microsoft.AspNetCore.OutputCaching (8)

DefaultOutputCachePolicyProvider.cs (1)

16public DefaultOutputCachePolicyProvider(IOptions<OutputCacheOptions> options)

OutputCacheKeyProvider.cs (1)

26internal 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>>();

Microsoft.AspNetCore.OutputCaching.StackExchangeRedis (4)

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)

Microsoft.AspNetCore.RateLimiting (1)

RateLimitingMiddleware.cs (1)

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

Microsoft.AspNetCore.RequestDecompression (1)

DefaultRequestDecompressionProvider.cs (1)

20IOptions<RequestDecompressionOptions> options)

Microsoft.AspNetCore.ResponseCaching (3)

ResponseCachingKeyProvider.cs (1)

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

ResponseCachingMiddleware.cs (2)

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

Microsoft.AspNetCore.ResponseCompression (7)

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;

Microsoft.AspNetCore.Rewrite (3)

RewriteBuilderExtensions.cs (2)

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

RewriteMiddleware.cs (1)

36IOptions<RewriteOptions> options)

Microsoft.AspNetCore.Routing (13)

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;

Microsoft.AspNetCore.Server.HttpSys (2)

MessagePump.cs (1)

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

WebHostBuilderHttpSysExtensions.cs (1)

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

Microsoft.AspNetCore.Server.IIS (1)

Core\IISHttpServer.cs (1)

64IOptions<IISServerOptions> options,

Microsoft.AspNetCore.Server.IISIntegration (2)

IISMiddleware.cs (2)

52IOptions<IISOptions> options, 72IOptions<IISOptions> options,

Microsoft.AspNetCore.Server.Kestrel.Core (4)

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)

Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes (1)

Internal\NamedPipeTransportFactory.cs (1)

23IOptions<NamedPipeTransportOptions> options,

Microsoft.AspNetCore.Server.Kestrel.Transport.Quic (1)

QuicTransportFactory.cs (1)

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

Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets (2)

Client\SocketConnectionFactory.cs (1)

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

SocketTransportFactory.cs (1)

26IOptions<SocketTransportOptions> options,

Microsoft.AspNetCore.Session (1)

SessionMiddleware.cs (1)

40IOptions<SessionOptions> options)

Microsoft.AspNetCore.SignalR.Client (1)

HubConnectionBuilderHttpExtensions.cs (1)

170public HttpConnectionOptionsDerivedHttpEndPoint(IOptions<HttpConnectionOptions> httpConnectionOptions)

Microsoft.AspNetCore.SignalR.Client.Core (4)

HubConnection.cs (4)

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

Microsoft.AspNetCore.SignalR.Core (3)

HubConnectionHandler.cs (2)

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

HubOptionsSetup`T.cs (1)

20public HubOptionsSetup(IOptions<HubOptions> options)

Microsoft.AspNetCore.SignalR.Protocols.Json (1)

Protocol\JsonHubProtocol.cs (1)

68public JsonHubProtocol(IOptions<JsonHubProtocolOptions> options)

Microsoft.AspNetCore.SignalR.Protocols.MessagePack (1)

Protocol\MessagePackHubProtocol.cs (1)

46public MessagePackHubProtocol(IOptions<MessagePackHubProtocolOptions> options)

Microsoft.AspNetCore.SignalR.Protocols.NewtonsoftJson (1)

Protocol\NewtonsoftJsonHubProtocol.cs (1)

58public NewtonsoftJsonHubProtocol(IOptions<NewtonsoftJsonHubProtocolOptions> options)

Microsoft.AspNetCore.SignalR.StackExchangeRedis (4)

RedisHubLifetimeManager.cs (4)

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

Microsoft.AspNetCore.SpaProxy (3)

SpaProxyLaunchManager.cs (1)

26IOptions<SpaDevelopmentServerOptions> options)

SpaProxyMiddleware.cs (2)

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

Microsoft.AspNetCore.SpaServices.Extensions (4)

SpaApplicationBuilderExtensions.cs (2)

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

StaticFiles\SpaStaticFilesExtensions.cs (2)

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

Microsoft.AspNetCore.StaticFiles (4)

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)

Microsoft.AspNetCore.TestHost (2)

TestServer.cs (2)

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

Microsoft.AspNetCore.Testing (1)

ServiceFakesHostExtensions.cs (1)

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

Microsoft.AspNetCore.Testing.Tests (1)

FakesExtensionsTests.cs (1)

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

Microsoft.AspNetCore.WebSockets (1)

WebSocketMiddleware.cs (1)

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

Microsoft.Extensions.AmbientMetadata.Application.Tests (4)

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;

Microsoft.Extensions.AmbientMetadata.Build.Tests (4)

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);

Microsoft.Extensions.Caching.Hybrid (1)

Internal\DefaultHybridCache.cs (1)

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

Microsoft.Extensions.Caching.Hybrid.Tests (9)

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)

Microsoft.Extensions.Caching.Memory (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)

Microsoft.Extensions.Caching.SqlServer (2)

SqlServerCache.cs (1)

36public SqlServerCache(IOptions<SqlServerCacheOptions> options)

SqlServerCacheOptions.cs (1)

51SqlServerCacheOptions IOptions<SqlServerCacheOptions>.Value

Microsoft.Extensions.Caching.StackExchangeRedis (5)

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

Microsoft.Extensions.Compliance.Abstractions.Tests (2)

Classification\DataClassificationTypeConverterTests.cs (2)

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

Microsoft.Extensions.Compliance.Redaction (2)

HmacRedactor.cs (1)

42public HmacRedactor(IOptions<HmacRedactorOptions> options)

RedactorProvider.cs (1)

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

Microsoft.Extensions.Compliance.Testing (4)

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());

Microsoft.Extensions.DependencyInjection.AutoActivation (1)

AutoActivationHostedService.cs (1)

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

Microsoft.Extensions.DependencyInjection.AutoActivation.Tests (1)

AutoActivationHostedServiceTests.cs (1)

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

Microsoft.Extensions.Diagnostics.HealthChecks (6)

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,

Microsoft.Extensions.Diagnostics.HealthChecks.Common (1)

TelemetryHealthCheckPublisher.cs (1)

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

Microsoft.Extensions.Diagnostics.HealthChecks.Common.Tests (3)

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

Microsoft.Extensions.Diagnostics.HealthChecks.ResourceUtilization (2)

ResourceUtilizationHealthCheck.cs (2)

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

Microsoft.Extensions.Diagnostics.HealthChecks.ResourceUtilization.Tests (9)

Linux\LinuxResourceHealthCheckTests.cs (2)

175var resourceMonitoringOptions = Options.Options.Create<ResourceMonitoringOptions>(new()); 228var options = Microsoft.Extensions.Options.Options.Create(checkOptions);

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 (3)

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

Microsoft.Extensions.Diagnostics.Probes.Tests (4)

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);

Microsoft.Extensions.Diagnostics.ResourceMonitoring (10)

Linux\Disk\LinuxSystemDiskMetrics.cs (1)

47IOptions<ResourceMonitoringOptions> options,

Linux\LinuxResourceQuotaProvider.cs (1)

13public LinuxResourceQuotaProvider(ILinuxUtilizationParser parser, IOptions<ResourceMonitoringOptions> options)

Linux\LinuxUtilizationProvider.cs (1)

55IOptions<ResourceMonitoringOptions> options,

Linux\Network\LinuxTcpStateInfo.cs (1)

20public LinuxTcpStateInfo(IOptions<ResourceMonitoringOptions> options, LinuxNetworkUtilizationParser parser)

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)

Microsoft.Extensions.Diagnostics.ResourceMonitoring.Kubernetes.Tests (1)

Linux\AcceptanceTest.cs (1)

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

Microsoft.Extensions.Diagnostics.ResourceMonitoring.Tests (23)

Linux\AcceptanceTest.cs (4)

68var options = services.GetRequiredService<IOptions<ResourceMonitoringOptions>>(); 91var options = services.GetRequiredService<IOptions<ResourceMonitoringOptions>>();

Linux\LinuxCountersTests.cs (1)

81var options = Microsoft.Extensions.Options.Options.Create<ResourceMonitoringOptions>(new());

Linux\LinuxUtilizationProviderTests.cs (11)

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)

29private readonly IOptions<ResourceMonitoringOptions> _options;

Microsoft.Extensions.Diagnostics.Testing (1)

Logging\FakeLogCollector.cs (1)

28public FakeLogCollector(IOptions<FakeLogCollectorOptions> options)

Microsoft.Extensions.Hosting (6)

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)

Microsoft.Extensions.Hosting.WindowsServices (5)

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)

Microsoft.Extensions.Http.Diagnostics (2)

Latency\Internal\HttpLatencyTelemetryHandler.cs (2)

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

Microsoft.Extensions.Http.Diagnostics.Tests (16)

Latency\HttpClientLatencyTelemetryExtensionsTest.cs (3)

51var options = sp.GetRequiredService<IOptions<HttpClientLatencyTelemetryOptions>>().Value; 85var options = sp.GetRequiredService<IOptions<HttpClientLatencyTelemetryOptions>>().Value; 105var 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)

146var options = provider.GetRequiredService<IOptions<LoggingOptions>>().Value; 507var options = provider.GetRequiredService<IOptions<LoggingOptions>>().Value; 604.GetRequiredService<IOptions<LoggingOptions>>().Value; 631var options = provider.GetRequiredService<IOptions<LoggingOptions>>().Value;

Microsoft.Extensions.Http.Resilience.Tests (1)

Resilience\HttpClientBuilderExtensionsTests.Resilience.cs (1)

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

Microsoft.Extensions.Identity.Core (4)

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,

Microsoft.Extensions.Localization (2)

ResourceManagerStringLocalizerFactory.cs (2)

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

Microsoft.Extensions.Logging (2)

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)

Microsoft.Extensions.Logging.EventLog (2)

EventLogLoggerProvider.cs (2)

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

Microsoft.Extensions.ML (5)

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,

Microsoft.Extensions.ML.Tests (3)

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,

Microsoft.Extensions.Options (20)

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)

OptionsBuilder.cs (12)

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)

Microsoft.Extensions.Resilience.Tests (2)

Resilience\ResilienceServiceCollectionExtensionsTests.cs (2)

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

Microsoft.Extensions.ServiceDiscovery (15)

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 (3)

36var options = services.GetRequiredService<IOptions<ServiceDiscoveryOptions>>(); 69public DisableGrpcLoadBalancingFilter(IOptions<DisableGrpcLoadBalancingFilterOptions> options)

ServiceEndpointWatcher.cs (1)

21IOptions<ServiceDiscoveryOptions> options) : IAsyncDisposable

ServiceEndpointWatcherFactory.cs (2)

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

Microsoft.Extensions.ServiceDiscovery.Dns (1)

Resolver\DnsResolver.cs (1)

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

Microsoft.Extensions.ServiceDiscovery.Dns.Tests (8)

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>>();

Microsoft.Extensions.ServiceDiscovery.Yarp (1)

ServiceDiscoveryDestinationResolver.cs (1)

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

Microsoft.Extensions.ServiceDiscovery.Yarp.Tests (1)

YarpServiceDiscoveryTests.cs (1)

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

Microsoft.Extensions.Telemetry (9)

Buffering\GlobalBufferLoggingBuilderExtensions.cs (1)

96new LoggerFactoryScopeProvider(sp.GetRequiredService<IOptions<LoggerFactoryOptions>>().Value.ActivityTrackingOptions));

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,

Microsoft.Extensions.Telemetry.Abstractions.Tests (2)

Latency\LatencyRegistryExtensionsTests.cs (2)

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

Microsoft.Extensions.Telemetry.Tests (37)

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>>();

Microsoft.Extensions.WebEncoders (1)

EncoderServiceCollectionExtensions.cs (1)

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

Microsoft.Gen.BuildMetadata.Generated.Tests (4)

BuildMetadataHostBuilderExtensionsTests.cs (4)

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