Optional Decorators?

Hello!

I have the following setup. This code is very similiar to my earlier question: https://github.com/khellang/Scrutor/issues/68

            services.Scan(s =>
            {
                s.FromAssembliesOf(typeof(ApplicationLayerServiceProviderExtensions))
                    .AddClasses(p => p.AssignableTo(typeof(ICommandHandler<>)).Where(x => !x.IsGenericType))
                    .AsClosedTypeOf(typeof(ICommandHandler<>))
                    .WithTransientLifetime();

                s.FromAssembliesOf(typeof(ApplicationLayerServiceProviderExtensions))
                    .AddClasses(p => p.AssignableTo(typeof(AbstractValidator<>)).Where(x => !x.IsGenericType))
                    .AsClosedTypeOf(typeof(IValidator<>))
                    .WithTransientLifetime();
            });

            services.Decorate(typeof(ICommandHandler<>), typeof(ValidationCommandHandlerDecorator<>));
            services.Decorate(typeof(ICommandHandler<>), typeof(LoggingCommandHandlerDecorator<>));

The AsClosedTypeOf() code is this:

        public static ILifetimeSelector AsClosedTypeOf(this IServiceTypeSelector selector, Type closedType)
        {
            return selector.As(t => t
                .GetInterfaces()
                .Where(p => p.IsGenericType && p.GetGenericTypeDefinition() == closedType)
            );
        }

my ValidationCommandHandlerDecorator<> looks like this:

    public class ValidationCommandHandlerDecorator<TCommand>
        : ICommandHandler<TCommand> where TCommand : ICommand
    {
        private readonly ICommandHandler<TCommand> _innerHandler;
        private readonly IValidator<TCommand> _validator;

        public ValidationCommandHandlerDecorator(
            ICommandHandler<TCommand> innerHandler,
            IValidator<TCommand> validator)
        {
            _innerHandler = innerHandler;
            _validator = validator;
        }

        public Task HandleAsync(TCommand command)
        {
            var validationResult = _validator.Validate(command);

            // Other code is omitted

            return _innerHandler.HandleAsync(command);
        }
    }

Right now, I need to create an implementation of IValidator<> for every command that gets executed. If it does not exist, an exception is thrown because the implementation can’t be found.

I would like to support that Ivalidator<> is optional. Sometimes I have a command that I need no validator for. Right now I HAVE to create an implementation of IValidator<> that is just an empty class to satisfy this code.

Could you help me out?

[sander1095]

I am now using your last suggestion (IValidator<TCommand> validator = null) and that works! thanks!

[sander1095]

Thank you very much, I will try this out!