private static string UniqueComponentName(Microsoft.Extensions.DependencyInjection.ServiceDescriptor service) { return ((service.ImplementationType?.FullName ?? service.ImplementationInstance?.GetType().FullName ?? service.ImplementationFactory.GetType().FullName ) + "@" + Guid.NewGuid().ToString()); }
public static void AddIfNot <TService, TImplement>(this IServiceCollection services, ServiceLifetime lifetime) where TImplement : class, TService { Throw.IfArgumentNull(services, nameof(services)); if (!services.IsRegistered(typeof(TService))) { services.Add(ServiceDescriptor.Describe(typeof(TService), typeof(TImplement), lifetime)); } }
public static void AddDecorator <TService, TDecorator>(this IServiceCollection services, ServiceLifetime lifetime = ServiceLifetime.Scoped) where TService : class where TDecorator : class { var serviceDescriptor = new ServiceDescriptor( typeof(TService), provider => Construct <TService, TDecorator>(provider, services), lifetime); services.Add(serviceDescriptor); }
public static IRegistration CreateWindsorRegistration(this Microsoft.Extensions.DependencyInjection.ServiceDescriptor service) { if (service.ServiceType.ContainsGenericParameters) { return(RegistrationAdapter.FromOpenGenericServiceDescriptor(service)); } else { var method = typeof(RegistrationAdapter).GetMethod("FromServiceDescriptor", BindingFlags.Static | BindingFlags.Public).MakeGenericMethod(service.ServiceType); return(method.Invoke(null, new object[] { service }) as IRegistration); } }
private void RegisterWindsor(Microsoft.Extensions.DependencyInjection.ServiceDescriptor item) { try { ComponentRegistration <object> r = null; if (item.ImplementationType != null) { if (_container.Kernel.HasComponent(item.ImplementationType)) { return; } r = Component.For(item.ServiceType).ImplementedBy(item.ImplementationType); } else if (item.ImplementationFactory != null) { var provider = WindsorRegistrationHelper.CreateServiceProvider(_container, this); r = Component.For(item.ServiceType).UsingFactoryMethod(() => item.ImplementationFactory.Invoke(provider)); } else if (item.ImplementationInstance != null) { r = Component.For(item.ServiceType).UsingFactoryMethod(() => item.ImplementationInstance); } if (item.Lifetime == ServiceLifetime.Scoped) { _container.Register(r.LifestyleScoped()); } else if (item.Lifetime == ServiceLifetime.Transient) { _container.Register(r.LifestyleTransient()); } else if (item.Lifetime == ServiceLifetime.Singleton) { _container.Register(r.LifestyleSingleton()); } } catch (Exception ex) { if (!ex.Message.Contains("Component Microsoft.Extensions.Options.OptionsManager`1 could not be registered") && !ex.Message.Contains("Component Late bound Microsoft.Extensions.Options.IConfigureOptions`1[[Microsoft.Extensions.Logging.LoggerFilterOptions, Microsoft.Extensions.Logging")) { // Known issue at: https://gist.github.com/cwe1ss/050a531e2711f5b62ab0 throw; } } }
public static IRegistration FromOpenGenericServiceDescriptor(Microsoft.Extensions.DependencyInjection.ServiceDescriptor service) { ComponentRegistration <object> registration = Component.For(service.ServiceType) .NamedAutomatically(UniqueComponentName(service)); if (service.ImplementationType != null) { registration = UsingImplementation(registration, service); } else { throw new System.ArgumentException("Unsupported ServiceDescriptor"); } return(ResolveLifestyle(registration, service) .IsDefault()); }
private static void MultipleImplementationWithReplace() { IServiceCollection services = new ServiceCollection(); services.AddTransient <IHasValue, MyClassWithValue>(); services.Replace(ServiceDescriptor.Transient <IHasValue, MyClassWithValue2>()); var serviceProvider = services.BuildServiceProvider(); var myServices = serviceProvider.GetServices <IHasValue>().ToList(); System.Console.WriteLine("----- Multiple Implemantation Replace ------------"); foreach (var service in myServices) { System.Console.WriteLine(service.Value); } System.Console.WriteLine("--------------------------------------------------"); }
private static void RegisterServiceDescriptor(IWindsorContainer container, ServiceDescriptor serviceDescriptor) { // MS allows the same type to be registered multiple times. // Castle Windsor throws an exception in that case - it requires an unique name. // For that reason, we use Guids to ensure uniqueness. string uniqueName = serviceDescriptor.ServiceType.FullName + "_" + Guid.NewGuid(); // The IsDefault() calls are important because this makes sure that the last service // is returned in case of multiple registrations. This is by design in the MS library: // https://github.com/aspnet/DependencyInjection/blob/dev/src/Microsoft.Extensions.DependencyInjection.Specification.Tests/DependencyInjectionSpecificationTests.cs#L254 if (serviceDescriptor.ImplementationType != null) { container.Register( Component.For(serviceDescriptor.ServiceType) .Named(uniqueName) .IsDefault() .ImplementedBy(serviceDescriptor.ImplementationType) .ConfigureLifecycle(serviceDescriptor.Lifetime)); } else if (serviceDescriptor.ImplementationFactory != null) { var serviceDescriptorRef = serviceDescriptor; container.Register( Component.For(serviceDescriptor.ServiceType) .Named(uniqueName) .IsDefault() .UsingFactoryMethod(c => serviceDescriptorRef.ImplementationFactory(c.Resolve <IServiceProvider>())) .ConfigureLifecycle(serviceDescriptor.Lifetime) ); } else { container.Register( Component.For(serviceDescriptor.ServiceType) .Named(uniqueName) .IsDefault() .Instance(serviceDescriptor.ImplementationInstance) .ConfigureLifecycle(serviceDescriptor.Lifetime) ); } }
internal static string UniqueComponentName(Microsoft.Extensions.DependencyInjection.ServiceDescriptor service) { var result = ""; if (service.ImplementationType != null) { result = service.ImplementationType.FullName; } else if (service.ImplementationInstance != null) { result = service.ImplementationInstance.GetType().FullName; } else { result = service.ImplementationFactory.GetType().FullName; } result = result + "@" + Guid.NewGuid().ToString(); return(result); }
public static IRegistration FromServiceDescriptor(Microsoft.Extensions.DependencyInjection.ServiceDescriptor service) { var registration = Component.For(service.ServiceType) .NamedAutomatically(UniqueComponentName(service)); if (service.ImplementationFactory != null) { registration = UsingFactoryMethod(registration, service); } else if (service.ImplementationInstance != null) { registration = UsingInstance(registration, service); } else if (service.ImplementationType != null) { registration = UsingImplementation(registration, service); } return(ResolveLifestyle(registration, service) .IsDefault()); }
public int IndexOf(Microsoft.Extensions.DependencyInjection.ServiceDescriptor item) { return(_descriptors.IndexOf(item)); }
void ICollection <Microsoft.Extensions.DependencyInjection.ServiceDescriptor> .Add(Microsoft.Extensions.DependencyInjection.ServiceDescriptor item) { RegisterWindsor(item); _descriptors.Add(item); }
/// <inheritdoc /> public bool Remove(Microsoft.Extensions.DependencyInjection.ServiceDescriptor item) { return(_descriptors.Remove(item)); }
/// <inheritdoc /> public bool Contains(Microsoft.Extensions.DependencyInjection.ServiceDescriptor item) { return(_descriptors.Contains(item)); }
private static ComponentRegistration <TService> UsingFactoryMethod <TService>(ComponentRegistration <TService> registration, Microsoft.Extensions.DependencyInjection.ServiceDescriptor service) where TService : class { return(registration.UsingFactoryMethod((kernel) => { var serviceProvider = kernel.Resolve <System.IServiceProvider>(); return service.ImplementationFactory(serviceProvider) as TService; })); }
public void Insert(int index, Microsoft.Extensions.DependencyInjection.ServiceDescriptor item) { RegisterWindsor(item); _descriptors.Insert(index, item); }
public static IMetricsHostBuilder AddGlobalFilter(this IMetricsHostBuilder builder, IMetricsFilter filter) { builder.Services.Replace(ServiceDescriptor.Singleton(filter)); return(builder); }
public static IServiceCollection ReplaceConfiguration(this IServiceCollection services, IConfiguration configuration) { return(services.Replace(ServiceDescriptor.Singleton <IConfiguration>(configuration))); }
private static void AddOpenTelemetryInternal(IServiceCollection services) { services.TryAddEnumerable(ServiceDescriptor.Singleton <IHostedService, TelemetryHostedService>()); }
// To enable unit testing internal static void AddMvcCoreServices(IServiceCollection services) { // // Options // services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <MvcOptions>, MvcCoreMvcOptionsSetup>()); services.TryAddEnumerable( ServiceDescriptor.Transient <IPostConfigureOptions <MvcOptions>, MvcCoreMvcOptionsSetup>()); services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <ApiBehaviorOptions>, ApiBehaviorOptionsSetup>()); services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <RouteOptions>, MvcCoreRouteOptionsSetup>()); // // Action Discovery // // These are consumed only when creating action descriptors, then they can be deallocated services.TryAddSingleton <ApplicationModelFactory>(); services.TryAddEnumerable( ServiceDescriptor.Transient <IApplicationModelProvider, DefaultApplicationModelProvider>()); services.TryAddEnumerable( ServiceDescriptor.Transient <IApplicationModelProvider, ApiBehaviorApplicationModelProvider>()); services.TryAddEnumerable( ServiceDescriptor.Transient <IActionDescriptorProvider, ControllerActionDescriptorProvider>()); services.TryAddSingleton <IActionDescriptorCollectionProvider, DefaultActionDescriptorCollectionProvider>(); // // Action Selection // services.TryAddSingleton <IActionSelector, ActionSelector>(); services.TryAddSingleton <ActionConstraintCache>(); // Will be cached by the DefaultActionSelector services.TryAddEnumerable(ServiceDescriptor.Transient <IActionConstraintProvider, DefaultActionConstraintProvider>()); // Policies for Endpoints services.TryAddEnumerable(ServiceDescriptor.Singleton <MatcherPolicy, ActionConstraintMatcherPolicy>()); // // Controller Factory // // This has a cache, so it needs to be a singleton services.TryAddSingleton <IControllerFactory, DefaultControllerFactory>(); // Will be cached by the DefaultControllerFactory services.TryAddTransient <IControllerActivator, DefaultControllerActivator>(); services.TryAddSingleton <IControllerFactoryProvider, ControllerFactoryProvider>(); services.TryAddSingleton <IControllerActivatorProvider, ControllerActivatorProvider>(); services.TryAddEnumerable( ServiceDescriptor.Transient <IControllerPropertyActivator, DefaultControllerPropertyActivator>()); // // Action Invoker // // The IActionInvokerFactory is cachable services.TryAddSingleton <IActionInvokerFactory, ActionInvokerFactory>(); services.TryAddEnumerable( ServiceDescriptor.Transient <IActionInvokerProvider, ControllerActionInvokerProvider>()); // These are stateless services.TryAddSingleton <ControllerActionInvokerCache>(); services.TryAddEnumerable( ServiceDescriptor.Singleton <IFilterProvider, DefaultFilterProvider>()); services.TryAddSingleton <IActionResultTypeMapper, ActionResultTypeMapper>(); // // Request body limit filters // services.TryAddTransient <RequestSizeLimitFilter>(); services.TryAddTransient <DisableRequestSizeLimitFilter>(); services.TryAddTransient <RequestFormLimitsFilter>(); // // ModelBinding, Validation // // The DefaultModelMetadataProvider does significant caching and should be a singleton. services.TryAddSingleton <IModelMetadataProvider, DefaultModelMetadataProvider>(); services.TryAdd(ServiceDescriptor.Transient <ICompositeMetadataDetailsProvider>(s => { var options = s.GetRequiredService <IOptions <MvcOptions> >().Value; return(new DefaultCompositeMetadataDetailsProvider(options.ModelMetadataDetailsProviders)); })); services.TryAddSingleton <IModelBinderFactory, ModelBinderFactory>(); services.TryAddSingleton <IObjectModelValidator>(s => { var options = s.GetRequiredService <IOptions <MvcOptions> >().Value; var metadataProvider = s.GetRequiredService <IModelMetadataProvider>(); return(new DefaultObjectValidator(metadataProvider, options.ModelValidatorProviders, options)); }); services.TryAddSingleton <ClientValidatorCache>(); services.TryAddSingleton <ParameterBinder>(); // // Random Infrastructure // services.TryAddSingleton <MvcMarkerService, MvcMarkerService>(); services.TryAddSingleton <ITypeActivatorCache, TypeActivatorCache>(); services.TryAddSingleton <IUrlHelperFactory, UrlHelperFactory>(); services.TryAddSingleton <IHttpRequestStreamReaderFactory, MemoryPoolHttpRequestStreamReaderFactory>(); services.TryAddSingleton <IHttpResponseStreamWriterFactory, MemoryPoolHttpResponseStreamWriterFactory>(); services.TryAddSingleton(ArrayPool <byte> .Shared); services.TryAddSingleton(ArrayPool <char> .Shared); services.TryAddSingleton <OutputFormatterSelector, DefaultOutputFormatterSelector>(); services.TryAddSingleton <IActionResultExecutor <ObjectResult>, ObjectResultExecutor>(); services.TryAddSingleton <IActionResultExecutor <PhysicalFileResult>, PhysicalFileResultExecutor>(); services.TryAddSingleton <IActionResultExecutor <VirtualFileResult>, VirtualFileResultExecutor>(); services.TryAddSingleton <IActionResultExecutor <FileStreamResult>, FileStreamResultExecutor>(); services.TryAddSingleton <IActionResultExecutor <FileContentResult>, FileContentResultExecutor>(); services.TryAddSingleton <IActionResultExecutor <RedirectResult>, RedirectResultExecutor>(); services.TryAddSingleton <IActionResultExecutor <LocalRedirectResult>, LocalRedirectResultExecutor>(); services.TryAddSingleton <IActionResultExecutor <RedirectToActionResult>, RedirectToActionResultExecutor>(); services.TryAddSingleton <IActionResultExecutor <RedirectToRouteResult>, RedirectToRouteResultExecutor>(); services.TryAddSingleton <IActionResultExecutor <RedirectToPageResult>, RedirectToPageResultExecutor>(); services.TryAddSingleton <IActionResultExecutor <ContentResult>, ContentResultExecutor>(); services.TryAddSingleton <IActionResultExecutor <JsonResult>, SystemTextJsonResultExecutor>(); services.TryAddSingleton <IClientErrorFactory, ProblemDetailsClientErrorFactory>(); services.TryAddSingleton <ProblemDetailsFactory, DefaultProblemDetailsFactory>(); // // Route Handlers // services.TryAddSingleton <MvcRouteHandler>(); // Only one per app services.TryAddTransient <MvcAttributeRouteHandler>(); // Many per app // // Endpoint Routing / Endpoints // services.TryAddSingleton <ControllerActionEndpointDataSourceFactory>(); services.TryAddSingleton <OrderedEndpointsSequenceProviderCache>(); services.TryAddSingleton <ControllerActionEndpointDataSourceIdProvider>(); services.TryAddSingleton <ActionEndpointFactory>(); services.TryAddSingleton <DynamicControllerEndpointSelectorCache>(); services.TryAddEnumerable(ServiceDescriptor.Singleton <MatcherPolicy, DynamicControllerEndpointMatcherPolicy>()); services.TryAddEnumerable(ServiceDescriptor.Singleton <IRequestDelegateFactory, ControllerRequestDelegateFactory>()); // // Middleware pipeline filter related // services.TryAddSingleton <MiddlewareFilterConfigurationProvider>(); // This maintains a cache of middleware pipelines, so it needs to be a singleton services.TryAddSingleton <MiddlewareFilterBuilder>(); // Sets ApplicationBuilder on MiddlewareFilterBuilder services.TryAddEnumerable(ServiceDescriptor.Singleton <IStartupFilter, MiddlewareFilterBuilderStartupFilter>()); }
private static IServiceCollection Add(this IServiceCollection services, ServiceDefinition service) { services.Add(ServiceDescriptor.Describe(service.ServiceType, service.ImplementationType, service.Lifetime)); return(services); }
// Internal for testing. internal static void AddViewServices(IServiceCollection services) { services.AddDataProtection(); services.AddAntiforgery(); services.AddWebEncoders(); services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <MvcViewOptions>, MvcViewOptionsSetup>()); services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <MvcOptions>, TempDataMvcOptionsSetup>()); // // View Engine and related infrastructure // services.TryAddSingleton <ICompositeViewEngine, CompositeViewEngine>(); services.TryAddSingleton <IActionResultExecutor <ViewResult>, ViewResultExecutor>(); services.TryAddSingleton <IActionResultExecutor <PartialViewResult>, PartialViewResultExecutor>(); // Support for activating ViewDataDictionary services.TryAddEnumerable( ServiceDescriptor .Transient <IControllerPropertyActivator, ViewDataDictionaryControllerPropertyActivator>()); // // HTML Helper // services.TryAddTransient <IHtmlHelper, HtmlHelper>(); services.TryAddTransient(typeof(IHtmlHelper <>), typeof(HtmlHelper <>)); services.TryAddSingleton <IHtmlGenerator, DefaultHtmlGenerator>(); services.TryAddSingleton <ModelExpressionProvider>(); // ModelExpressionProvider caches results. Ensure that it's re-used when the requested type is IModelExpressionProvider. services.TryAddSingleton <IModelExpressionProvider>(s => s.GetRequiredService <ModelExpressionProvider>()); services.TryAddSingleton <ValidationHtmlAttributeProvider, DefaultValidationHtmlAttributeProvider>(); services.TryAddSingleton <IJsonHelper, SystemTextJsonHelper>(); // Component services for Blazor server-side interop services.TryAddSingleton <ServerComponentSerializer>(); // Component services for Blazor webassembly interop services.TryAddSingleton <WebAssemblyComponentSerializer>(); // // View Components // // These do caching so they should stay singleton services.TryAddSingleton <IViewComponentSelector, DefaultViewComponentSelector>(); services.TryAddSingleton <IViewComponentFactory, DefaultViewComponentFactory>(); services.TryAddSingleton <IViewComponentActivator, DefaultViewComponentActivator>(); services.TryAddSingleton < IViewComponentDescriptorCollectionProvider, DefaultViewComponentDescriptorCollectionProvider>(); services.TryAddSingleton <IActionResultExecutor <ViewComponentResult>, ViewComponentResultExecutor>(); services.TryAddSingleton <ViewComponentInvokerCache>(); services.TryAddTransient <IViewComponentDescriptorProvider, DefaultViewComponentDescriptorProvider>(); services.TryAddSingleton <IViewComponentInvokerFactory, DefaultViewComponentInvokerFactory>(); services.TryAddTransient <IViewComponentHelper, DefaultViewComponentHelper>(); // // Temp Data // services.TryAddEnumerable( ServiceDescriptor.Transient <IApplicationModelProvider, TempDataApplicationModelProvider>()); services.TryAddEnumerable( ServiceDescriptor.Transient <IApplicationModelProvider, ViewDataAttributeApplicationModelProvider>()); services.TryAddSingleton <SaveTempDataFilter>(); // // Component rendering // services.TryAddScoped <IComponentRenderer, ComponentRenderer>(); services.TryAddScoped <StaticComponentRenderer>(); services.TryAddScoped <HtmlRenderer>(); services.TryAddScoped <NavigationManager, HttpNavigationManager>(); services.TryAddScoped <IJSRuntime, UnsupportedJavaScriptRuntime>(); services.TryAddScoped <INavigationInterception, UnsupportedNavigationInterception>(); services.TryAddScoped <ComponentApplicationLifetime>(); services.TryAddScoped <ComponentApplicationState>(sp => sp.GetRequiredService <ComponentApplicationLifetime>().State); services.TryAddTransient <ControllerSaveTempDataPropertyFilter>(); // This does caching so it should stay singleton services.TryAddSingleton <ITempDataProvider, CookieTempDataProvider>(); services.TryAddSingleton <TempDataSerializer, DefaultTempDataSerializer>(); // // Antiforgery // services.TryAddSingleton <ValidateAntiforgeryTokenAuthorizationFilter>(); services.TryAddSingleton <AutoValidateAntiforgeryTokenAuthorizationFilter>(); // These are stateless so their lifetime isn't really important. services.TryAddSingleton <ITempDataDictionaryFactory, TempDataDictionaryFactory>(); services.TryAddSingleton(ArrayPool <ViewBufferValue> .Shared); services.TryAddScoped <IViewBufferScope, MemoryPoolViewBufferScope>(); }
public static FluentEmailServicesBuilder AddMailKitSender(this FluentEmailServicesBuilder builder, SmtpClientOptions smtpClientOptions) { builder.Services.TryAdd(ServiceDescriptor.Scoped <ISender>(x => new MailKitSender(smtpClientOptions))); return(builder); }
public static IServiceCollection AddHttpClientNewtonsoftJosn(this IServiceCollection services) { services.TryAddEnumerable(ServiceDescriptor.Singleton(typeof(IHttpContentSerializer), typeof(NewtonsoftJosnContentSerializer))); services.PostConfigure <JsonSerializerSettings>(i => { }); return(services); }
// Internal for testing. internal static void AddViewServices(IServiceCollection services) { services.AddDataProtection(); services.AddAntiforgery(); services.AddWebEncoders(); services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <MvcViewOptions>, MvcViewOptionsSetup>()); services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <MvcOptions>, TempDataMvcOptionsSetup>()); // // View Engine and related infrastructure // services.TryAddSingleton <ICompositeViewEngine, CompositeViewEngine>(); services.TryAddSingleton <ViewResultExecutor>(); services.TryAddSingleton <PartialViewResultExecutor>(); // Support for activating ViewDataDictionary services.TryAddEnumerable( ServiceDescriptor .Transient <IControllerPropertyActivator, ViewDataDictionaryControllerPropertyActivator>()); // // HTML Helper // services.TryAddTransient <IHtmlHelper, HtmlHelper>(); services.TryAddTransient(typeof(IHtmlHelper <>), typeof(HtmlHelper <>)); services.TryAddSingleton <IHtmlGenerator, DefaultHtmlGenerator>(); // // JSON Helper // services.TryAddSingleton <IJsonHelper, JsonHelper>(); services.TryAdd(ServiceDescriptor.Singleton <JsonOutputFormatter>(serviceProvider => { var options = serviceProvider.GetRequiredService <IOptions <MvcJsonOptions> >().Value; var charPool = serviceProvider.GetRequiredService <ArrayPool <char> >(); return(new JsonOutputFormatter(options.SerializerSettings, charPool)); })); // // View Components // // These do caching so they should stay singleton services.TryAddSingleton <IViewComponentSelector, DefaultViewComponentSelector>(); services.TryAddSingleton <IViewComponentFactory, DefaultViewComponentFactory>(); services.TryAddSingleton <IViewComponentActivator, DefaultViewComponentActivator>(); services.TryAddSingleton < IViewComponentDescriptorCollectionProvider, DefaultViewComponentDescriptorCollectionProvider>(); services.TryAddSingleton <ViewComponentInvokerCache>(); services.TryAddTransient <IViewComponentDescriptorProvider, DefaultViewComponentDescriptorProvider>(); services.TryAddSingleton <IViewComponentInvokerFactory, DefaultViewComponentInvokerFactory>(); services.TryAddTransient <IViewComponentHelper, DefaultViewComponentHelper>(); // // Temp Data // // This does caching so it should stay singleton services.TryAddSingleton <ITempDataProvider, SessionStateTempDataProvider>(); // // Antiforgery // services.TryAddSingleton <ValidateAntiforgeryTokenAuthorizationFilter>(); services.TryAddSingleton <AutoValidateAntiforgeryTokenAuthorizationFilter>(); // These are stateless so their lifetime isn't really important. services.TryAddSingleton <ITempDataDictionaryFactory, TempDataDictionaryFactory>(); services.TryAddSingleton <SaveTempDataFilter>(); services.TryAddSingleton(ArrayPool <ViewBufferValue> .Shared); services.TryAddScoped <IViewBufferScope, MemoryPoolViewBufferScope>(); }
/// <summary> /// Registers the <see cref="WsFederationHandler"/> using the given authentication scheme, display name, and options configuration. /// </summary> /// <param name="builder"></param> /// <param name="authenticationScheme"></param> /// <param name="displayName"></param> /// <param name="configureOptions">A delegate that configures the <see cref="WsFederationOptions"/>.</param> /// <returns></returns> public static AuthenticationBuilder AddWsFederation(this AuthenticationBuilder builder, string authenticationScheme, string displayName, Action <WsFederationOptions> configureOptions) { builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IPostConfigureOptions <WsFederationOptions>, WsFederationPostConfigureOptions>()); return(builder.AddRemoteScheme <WsFederationOptions, WsFederationHandler>(authenticationScheme, displayName, configureOptions)); }
private static ComponentRegistration <TService> UsingImplementation <TService>(ComponentRegistration <TService> registration, Microsoft.Extensions.DependencyInjection.ServiceDescriptor service) where TService : class { return(registration.ImplementedBy(service.ImplementationType)); }
/// <summary> /// Adds cookie authentication to <see cref="AuthenticationBuilder"/> using the specified scheme. /// <para> /// Cookie authentication uses a HTTP cookie persisted in the client to perform authentication. /// </para> /// </summary> /// <param name="builder">The <see cref="AuthenticationBuilder"/>.</param> /// <param name="authenticationScheme">The authentication scheme.</param> /// <param name="displayName">A display name for the authentication handler.</param> /// <param name="configureOptions">A delegate to configure <see cref="CookieAuthenticationOptions"/>.</param> /// <returns>A reference to <paramref name="builder"/> after the operation has completed.</returns> public static AuthenticationBuilder AddCookie(this AuthenticationBuilder builder, string authenticationScheme, string?displayName, Action <CookieAuthenticationOptions> configureOptions) { builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton <IPostConfigureOptions <CookieAuthenticationOptions>, PostConfigureCookieAuthenticationOptions>()); builder.Services.AddOptions <CookieAuthenticationOptions>(authenticationScheme).Validate(o => o.Cookie.Expiration == null, "Cookie.Expiration is ignored, use ExpireTimeSpan instead."); return(builder.AddScheme <CookieAuthenticationOptions, CookieAuthenticationHandler>(authenticationScheme, displayName, configureOptions)); }
private static ComponentRegistration <TService> ResolveLifestyle <TService>(ComponentRegistration <TService> registration, Microsoft.Extensions.DependencyInjection.ServiceDescriptor service) where TService : class { switch (service.Lifetime) { case ServiceLifetime.Singleton: return(registration.LifeStyle.NetStatic()); case ServiceLifetime.Scoped: return(registration.LifeStyle.ScopedToNetServiceScope()); case ServiceLifetime.Transient: return(registration.LifestyleNetTransient()); default: throw new System.ArgumentException($"Invalid lifetime {service.Lifetime}"); } }
// Internal for testing. internal static void AddRazorViewEngineServices(IServiceCollection services) { services.TryAddSingleton <CSharpCompiler>(); #pragma warning disable CS0618 // Type or member is obsolete services.TryAddSingleton <RazorReferenceManager, DefaultRazorReferenceManager>(); #pragma warning restore CS0618 // Type or member is obsolete services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <MvcViewOptions>, MvcRazorMvcViewOptionsSetup>()); services.TryAddEnumerable( ServiceDescriptor.Transient <IConfigureOptions <RazorViewEngineOptions>, RazorViewEngineOptionsSetup>()); services.TryAddEnumerable( ServiceDescriptor.Transient <IPostConfigureOptions <RazorViewEngineOptions>, RazorViewEngineOptionsSetup>()); services.TryAddSingleton < IRazorViewEngineFileProviderAccessor, DefaultRazorViewEngineFileProviderAccessor>(); services.TryAddSingleton <IRazorViewEngine>(s => { var pageFactory = s.GetRequiredService <IRazorPageFactoryProvider>(); var pageActivator = s.GetRequiredService <IRazorPageActivator>(); var htmlEncoder = s.GetRequiredService <HtmlEncoder>(); var optionsAccessor = s.GetRequiredService <IOptions <RazorViewEngineOptions> >(); var razorFileSystem = s.GetRequiredService <RazorProjectFileSystem>(); var loggerFactory = s.GetRequiredService <ILoggerFactory>(); var diagnosticSource = s.GetRequiredService <DiagnosticSource>(); var viewEngine = new RazorViewEngine(pageFactory, pageActivator, htmlEncoder, optionsAccessor, razorFileSystem, loggerFactory, diagnosticSource); return(viewEngine); }); services.TryAddSingleton <IViewCompilerProvider, RazorViewCompilerProvider>(); services.TryAddSingleton <IViewCompilationMemoryCacheProvider, RazorViewCompilationMemoryCacheProvider>(); // In the default scenario the following services are singleton by virtue of being initialized as part of // creating the singleton RazorViewEngine instance. services.TryAddTransient <IRazorPageFactoryProvider, DefaultRazorPageFactoryProvider>(); // // Razor compilation infrastructure // services.TryAddSingleton <LazyMetadataReferenceFeature>(); services.TryAddSingleton <RazorProjectFileSystem, FileProviderRazorProjectFileSystem>(); services.TryAddSingleton(s => { var fileSystem = s.GetRequiredService <RazorProjectFileSystem>(); var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder => { RazorExtensions.Register(builder); // Roslyn + TagHelpers infrastructure var metadataReferenceFeature = s.GetRequiredService <LazyMetadataReferenceFeature>(); builder.Features.Add(metadataReferenceFeature); builder.Features.Add(new CompilationTagHelperFeature()); // TagHelperDescriptorProviders (actually do tag helper discovery) builder.Features.Add(new DefaultTagHelperDescriptorProvider()); builder.Features.Add(new ViewComponentTagHelperDescriptorProvider()); }); return(projectEngine); }); // Legacy Razor compilation services services.TryAddSingleton <RazorProject>(s => s.GetRequiredService <RazorProjectEngine>().FileSystem); services.TryAddSingleton <RazorTemplateEngine, MvcRazorTemplateEngine>(); services.TryAddSingleton(s => s.GetRequiredService <RazorProjectEngine>().Engine); // This caches Razor page activation details that are valid for the lifetime of the application. services.TryAddSingleton <IRazorPageActivator, RazorPageActivator>(); // Only want one ITagHelperActivator and ITagHelperComponentPropertyActivator so it can cache Type activation information. Types won't conflict. services.TryAddSingleton <ITagHelperActivator, DefaultTagHelperActivator>(); services.TryAddSingleton <ITagHelperComponentPropertyActivator, TagHelperComponentPropertyActivator>(); services.TryAddSingleton <ITagHelperFactory, DefaultTagHelperFactory>(); // TagHelperComponents manager services.TryAddScoped <ITagHelperComponentManager, TagHelperComponentManager>(); // Consumed by the Cache tag helper to cache results across the lifetime of the application. services.TryAddSingleton <IMemoryCache, MemoryCache>(); services.TryAddSingleton <TagHelperMemoryCacheProvider>(); }