Validation expression by properties.

Validation.cs

public class ValidationError
{
    public string Message { get; set; }

    public int StatusCode { get; set; }
}



public interface IValidator<TInstance> where TInstance : class
{
    IValidator<TInstance> AddRule<TProp>(Func<TInstance, TProp> expression, IValidationRule<TProp> validationRule);

    ValidationResult Validate(TInstance instance);
}

public class ValidationResult
{
    public IEnumerable<ValidationError> ValidationErrors { get; set; } = new List<ValidationError>();

    public bool Valid { get; set; } = true;

    public static ValidationResult Success => new ValidationResult();

    public ValidationResult Merge(ValidationResult validationResult)
    {
        return new ValidationResult
        {
            ValidationErrors = ValidationErrors.Concat(validationResult.ValidationErrors),
            Valid = Valid && validationResult.Valid,
        };
    }
}


public class Validator<TInstance> : IValidator<TInstance> where TInstance : class
{
    private class ValidatorEntry<TProp>
    {
        public Func<TInstance, TProp> Expression { get; set; }

        public IValidationRule<TProp> ValidatorRule { get; set; }
    }

    private readonly IList<dynamic> _container = new List<dynamic>();

    public IValidator<TInstance> AddRule<IRule>(Func<TInstance, IRule> expression, IValidationRule<IRule> validationRule)
    {
        var validationEntry = new ValidatorEntry<IRule>
        {
            Expression = expression,
            ValidatorRule = validationRule
        };

        _container.Add(validationEntry);

        return this;
    }

    public ValidationResult Validate(TInstance instance)
    {
        var validationResult = new ValidationResult();

        foreach (var validationEntry in _container)
        {
            var value = validationEntry.Expression?.Invoke(instance);

            validationResult = validationResult.Merge(validationEntry.ValidatorRule.Validate(value));
        }

        return validationResult;
    }
}

public interface IValidationRule<T>
{
    ValidationResult Validate(T arg);
}

public class ValidatorNameRule : IValidationRule<string>
{
    public ValidationResult Validate(string arg)
    {
        if (!string.IsNullOrEmpty(arg))
            return new ValidationResult
            {
                Valid = true,
            };

        return ValidationResult.Success;
    }
}


internal class Program
{
    private static object fileFormatId;

    private static void Main(string[] args)
    {
        var test = new Test
        {
            Age = 1,
            Name = "dddd"
        };

        var tesValidate = new Validator<Test>();
        tesValidate.AddRule(q => q.Name, new ValidatorNameRule());

        var ss = tesValidate.Validate(test);

        Console.WriteLine();
        Console.ReadLine();
    }
}