Composite validator

Hello, what do u think about this?

   `private class Base {
	    public int Int1 { get; } = 1;
	    public string Str { get; } = string.Empty;
    }

    private class Nested : Base {
	    public int NestedInt1 { get; } = 2;
	    public string NestedStr { get; } = string.Empty;
    }

	private class Single {
		public int SingleInt { get; } = 3;
		public string SingleStr { get; } = string.Empty;
	}

    private class CompositeTestValidator : CompositeValidator {
	    public CompositeTestValidator() {
			For<Base>(validator => {
				validator.RuleFor(x => x.Int1).GreaterThan(2);
				validator.RuleFor(x => x.Str).NotEmpty();
			});

			For<Nested>(validator => {
				validator.RuleFor(x => x.NestedInt1).GreaterThan(3);
				validator.RuleFor(x => x.NestedStr).NotEmpty();
			});

		    For<Single>(validator => {
			    validator.RuleFor(x => x.SingleInt).GreaterThan(4);
			    validator.RuleFor(x => x.SingleStr).NotEmpty();
		    });
		}
	}

	[Fact]
    public void test_composite_validation() {
	    var composite = new CompositeTestValidator();

	    var validationResultNested = composite.Validate(new Nested());
	    var validationResultBase = composite.Validate(new Base());
		var validationResultSingle = composite.Validate(new Single());

		Assert.False(validationResultBase.IsValid);
	    Assert.False(validationResultNested.IsValid);
		Assert.False(validationResultSingle.IsValid);

		Assert.Equal(2, validationResultBase.Errors.Count);
	    Assert.Equal(4, validationResultNested.Errors.Count);
		Assert.Equal(2, validationResultSingle.Errors.Count);
	}`

And implementation:

          `public abstract class CompositeValidator : ICompositeValidator {
	   private readonly IDictionary<Type, IValidator> _validators = new Dictionary<Type, IValidator>();

	/// <inheritdoc>
	/// <cref></cref>
	/// </inheritdoc>
	public ValidationResult Validate<T>(ValidationContext<T> context) {
		var baseValidatorsStack = BuildBaseValidatorsStack<T>();
		var validationResults = new List<ValidationResult>();
		while (baseValidatorsStack.Any())
		{
			validationResults.Add(baseValidatorsStack.Pop().Validate(context));
		}

		if (_validators.ContainsKey(typeof(T)))
		{
			validationResults.Add(_validators[typeof(T)].Validate(context));
		}
		return new ValidationResult(validationResults.SelectMany(x => x.Errors));
	}

	/// <inheritdoc>
	/// <cref></cref>
	/// </inheritdoc>
	public async Task<ValidationResult> ValidateAsync<T>(ValidationContext<T> context, CancellationToken cancellation = new CancellationToken()) {
		var baseValidatorsStack = BuildBaseValidatorsStack<T>();
		var validationResults = new List<ValidationResult>();
		while (baseValidatorsStack.Any()) {
			validationResults.Add(await baseValidatorsStack.Pop().ValidateAsync(context, cancellation));
		}

		if (_validators.ContainsKey(typeof(T))) {
			validationResults.Add(await _validators[typeof(T)].ValidateAsync(context, cancellation));
		}
		return new ValidationResult(validationResults.SelectMany(x => x.Errors));
	}

	private Stack<IValidator> BuildBaseValidatorsStack<T>() {
		var baseType = typeof(T).GetTypeInfo().BaseType;
		var baseValidatorsStack = new Stack<IValidator>();
		while (baseType != null)
		{
			if (_validators.ContainsKey(baseType) && baseType != typeof(T))
			{
				baseValidatorsStack.Push(_validators[baseType]);
			}

			baseType = baseType.GetTypeInfo().BaseType;
		}

		return baseValidatorsStack;
	}

	/// <inheritdoc>
	/// <cref></cref>
	/// </inheritdoc>
	public ValidationResult Validate<T>(T instance) {
		return Validate(BuildContext(instance));
	}

	/// <inheritdoc>
	/// <cref></cref>
	/// </inheritdoc>
	public Task<ValidationResult> ValidateAsync<T>(T instance, CancellationToken cancellation = new CancellationToken()) {
		return ValidateAsync(BuildContext(instance), cancellation);
	}

	private ValidationContext<T> BuildContext<T>(T instance) {
		return new ValidationContext<T>(instance, new PropertyChain(), ValidatorOptions.ValidatorSelectors.DefaultValidatorSelectorFactory());
	}

	/// <inheritdoc>
	/// <cref></cref>
	/// </inheritdoc>
	public void For<T>(Action<AbstractValidator<T>> configure)
	{
		var validator = new InlineValidator<T>();
		_validators.Add(typeof(T), validator);
		configure(validator);
	}`

Anyway thank you for you time!

[JeremySkinner]

I don’t think this is something we’d include in the core package - it’s not a common use case for FluentValidation, and it’s easy enough to implement yourself if you want this behaviour in your own project.

[JeremySkinner]

Hello. This seems like a reasonable approach. Personally I prefer not to use FluentValidation with inheritance hierarchies, and only use it with flattened data structures (eg view models), but if you want to use it this way you certainly can. I prefer your second approach (with HierarchyValidator<T>) over the CompositeValidator.

Also just a tip, with github you need to use triple-backticks to create code blocks (see https://help.github.com/articles/creating-and-highlighting-code-blocks/)