Using custom validators for validating nullable reference types

Which version of FluentValidation are you using? 9.3.0

Issue description

1. Nullable Reference Types enabled.
2. Have a following classes

public class Data { ... }
public class Model {
    ...
    public Data? Data 
    ...
}

How to write validators in this case?

Option 1: Using non nullable reference type as type parameter:

public class DataValidator : AbstractValidator<Data> { ... }

But in this case we will get an error in Model Validator

public class ModelValidator : AbstractValidator<Model> 
{
    public ModelValidator () 
    {
        RuleFor(x => x.Data).SetValidator(new DataValidator ());
    }
}

This will generate following error on line with “SetValidator” call

Error CS8620 Argument of type 'DataValidator ' cannot be used for parameter 'validator' of type 'IValidator<Data?>' in 'IRuleBuilderOptions<Model, Data?> IRuleBuilder<Model, Data?>.SetValidator(IValidator<Data?> validator, params string[] ruleSets)' due to differences in the nullability of reference types.

Option 2: Using nullable reference type as type parameter:

public class DataValidator : AbstractValidator<Data?> 
{ 
    public DataValidator() 
    {
        RuleFor(x => x.SomeDataProperty)...
    }
}

This will raise Error CS8602 Dereference of a possibly null reference. at line with “RuleFor” call because it uses nullable reference type property without checking against null.

How to create validator correctly?

PS: Following code will compile but looks like hack fix to me (x!.SomeDataProperty)

public class DataValidator : AbstractValidator<Data?> 
{ 
    public DataValidator() 
    {
        RuleFor(x => x!.SomeDataProperty)...
    }
}

[JeremySkinner]

Here’s an implementation of the same method that works on 10.0:

public static class DemoExtensions {
	public static IRuleBuilderOptions<T, TProperty?> SetNonNullableValidator<T, TProperty>(this IRuleBuilder<T, TProperty?> ruleBuilder, IValidator<TProperty> validator, params string[] ruleSets) {
		var adapter = new NullableChildValidatorAdaptor<T, TProperty>(validator, validator.GetType()) {
			RuleSets = ruleSets
		};

		return ruleBuilder.SetAsyncValidator((IAsyncPropertyValidator<T,TProperty?>)adapter);
	}

	private class NullableChildValidatorAdaptor<T, TProperty> : ChildValidatorAdaptor<T, TProperty>, IPropertyValidator<T, TProperty?>, IAsyncPropertyValidator<T,TProperty?> {
		public NullableChildValidatorAdaptor(IValidator<TProperty> validator, Type validatorType)
			: base(validator, validatorType) {
		}

		public override bool IsValid(ValidationContext<T> context, TProperty? value) {
			return base.IsValid(context, value!);
		}

		public override Task<bool> IsValidAsync(ValidationContext<T> context, TProperty? value, CancellationToken cancellation) {
			return base.IsValidAsync(context, value!, cancellation);
		}
	}
}

[VeselovAndrey]

Took a fresh look today. And get rid of interface implementation and no need to inherit ChildValidatorAdaptor. It’s very simple solution:

public static IRuleBuilderOptions<TTarget, TProperty?> SetNonNullableValidator<TTarget, TProperty>(this IRuleBuilder<TTarget, TProperty?> ruleBuilder, IValidator<TProperty> validator, params string[] ruleSets)
{
	var adapter = new ChildValidatorAdaptor<TTarget, TProperty>(validator, validator.GetType())
	{
		RuleSets = ruleSets
	};

	return ruleBuilder.SetValidator(adapter);
}