/// <summary> /// Decorate all components implementing service <paramref name="serviceType"/> /// with decorator service <paramref name="decoratorType"/>. /// </summary> /// <param name="builder">Container builder.</param> /// <param name="decoratorType">Service type of the decorator. Must accept a parameter /// of type <paramref name="serviceType"/>, which will be set to the instance being decorated.</param> /// <param name="serviceType">Service type being decorated.</param> /// <param name="condition">A function that when provided with an <see cref="IDecoratorContext"/> /// instance determines if the decorator should be applied.</param> public static void RegisterDecorator( this ContainerBuilder builder, Type decoratorType, Type serviceType, Func <IDecoratorContext, bool>?condition = null) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (decoratorType == null) { throw new ArgumentNullException(nameof(decoratorType)); } if (serviceType == null) { throw new ArgumentNullException(nameof(serviceType)); } var decoratorService = new DecoratorService(serviceType, condition); var rb = RegistrationBuilder.ForType(decoratorType).As(decoratorService); var decoratorRegistration = rb.CreateRegistration(); var middleware = new DecoratorMiddleware(decoratorService, decoratorRegistration); builder.RegisterServiceMiddleware(serviceType, middleware, MiddlewareInsertionMode.StartOfPhase); // Add the decorator to the registry so the pipeline gets built. builder.RegisterCallback(crb => crb.Register(decoratorRegistration)); }
/// <summary> /// Decorate all components implementing service <typeparamref name="TService"/> /// using the provided <paramref name="decorator"/> function. /// </summary> /// <typeparam name="TService">Service type being decorated.</typeparam> /// <param name="builder">Container builder.</param> /// <param name="decorator">Function decorating a component instance that provides /// <typeparamref name="TService"/>, given the context, parameters and service to decorate.</param> /// <param name="condition">A function that when provided with an <see cref="IDecoratorContext"/> /// instance determines if the decorator should be applied.</param> public static void RegisterDecorator <TService>( this ContainerBuilder builder, Func <IComponentContext, IEnumerable <Parameter>, TService, TService> decorator, Func <IDecoratorContext, bool>?condition = null) where TService : class { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } if (decorator == null) { throw new ArgumentNullException(nameof(decorator)); } var service = new DecoratorService(typeof(TService), condition); var rb = RegistrationBuilder.ForDelegate((c, p) => { TService?instance = (TService?)p .OfType <TypedParameter>() .FirstOrDefault(tp => tp.Type == typeof(TService)) ?.Value; if (instance == null) { throw new DependencyResolutionException(string.Format(CultureInfo.CurrentCulture, RegistrationExtensionsResources.DecoratorRequiresInstanceParameter, typeof(TService).Name)); } return(decorator(c, p, instance)); }).As(service); var decoratorRegistration = rb.CreateRegistration(); var middleware = new DecoratorMiddleware(service, decoratorRegistration); builder.RegisterServiceMiddleware <TService>(middleware, MiddlewareInsertionMode.StartOfPhase); // Add the decorator to the registry so the pipeline gets built. builder.RegisterCallback(crb => crb.Register(decoratorRegistration)); }
/// <summary> /// Decorate all components implementing service <typeparamref name="TService"/> /// with decorator service <typeparamref name="TDecorator"/>. /// </summary> /// <typeparam name="TDecorator">Service type of the decorator. Must accept a parameter /// of type <typeparamref name="TService"/>, which will be set to the instance being decorated.</typeparam> /// <typeparam name="TService">Service type being decorated.</typeparam> /// <param name="builder">Container builder.</param> /// <param name="condition">A function that when provided with an <see cref="IDecoratorContext"/> /// instance determines if the decorator should be applied.</param> public static void RegisterDecorator <[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TDecorator, TService>(this ContainerBuilder builder, Func <IDecoratorContext, bool>?condition = null) where TDecorator : notnull, TService { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } var decoratorService = new DecoratorService(typeof(TService), condition); var rb = RegistrationBuilder.ForType <TDecorator>().As(decoratorService); var decoratorRegistration = rb.CreateRegistration(); var middleware = new DecoratorMiddleware(decoratorService, decoratorRegistration); builder.RegisterServiceMiddleware <TService>(middleware, MiddlewareInsertionMode.StartOfPhase); // Add the decorator to the registry so the pipeline gets built. builder.RegisterCallback(crb => crb.Register(decoratorRegistration)); }
/// <summary> /// Register a resolve middleware for services providing a particular type. /// </summary> /// <typeparam name="TService">The service type.</typeparam> /// <param name="builder">The container builder.</param> /// <param name="descriptor">A description for the middleware; this will show up in any resolve tracing.</param> /// <param name="phase">The phase of the pipeline the middleware should run at.</param> /// <param name="callback"> /// A callback invoked to run your middleware. /// This callback takes a <see cref="ResolveRequestContext"/>, containing the context for the resolve request, plus /// a callback to invoke to continue the pipeline. /// </param> public static void RegisterServiceMiddleware <TService>(this ContainerBuilder builder, string descriptor, PipelinePhase phase, Action <ResolveRequestContext, Action <ResolveRequestContext> > callback) { builder.RegisterServiceMiddleware <TService>(descriptor, phase, MiddlewareInsertionMode.EndOfPhase, callback); }
/// <summary> /// Register a resolve middleware for services providing a particular type. /// </summary> /// <typeparam name="TService">The service type.</typeparam> /// <param name="builder">The container builder.</param> /// <param name="middleware">The middleware to register.</param> /// <param name="insertionMode">The insertion mode of the middleware (start or end of phase).</param> public static void RegisterServiceMiddleware <TService>(this ContainerBuilder builder, IResolveMiddleware middleware, MiddlewareInsertionMode insertionMode = MiddlewareInsertionMode.EndOfPhase) { builder.RegisterServiceMiddleware(typeof(TService), middleware, insertionMode); }
/// <summary> /// Register a resolve middleware for services providing a particular type. /// </summary> /// <typeparam name="TService">The service type.</typeparam> /// <param name="builder">The container builder.</param> /// <param name="descriptor">A description for the middleware; this will show up in any resolve tracing.</param> /// <param name="phase">The phase of the pipeline the middleware should run at.</param> /// <param name="callback"> /// A callback invoked to run your middleware. /// This callback takes a <see cref="ResolveRequestContext"/>, containing the context for the resolve request, plus /// a callback to invoke to continue the pipeline. /// </param> /// <param name="insertionMode">The insertion mode of the middleware (start or end of phase).</param> public static void RegisterServiceMiddleware <TService>(this ContainerBuilder builder, string descriptor, PipelinePhase phase, MiddlewareInsertionMode insertionMode, Action <ResolveRequestContext, Action <ResolveRequestContext> > callback) { builder.RegisterServiceMiddleware(typeof(TService), new DelegateMiddleware(descriptor, phase, callback), insertionMode); }