Mfcttrf

Inspired by this question by t3chb0t and as an elaboration of my own answer, I have written the following solution. My goal was to reduce complexity both in implementation and use. Eventually - I have to admit - the implementation ended up being rather complex - but in my flavor; but in terms of ease of use, I think I succeeded. My original idea was inspired by Railway Oriented Programming, but I don't think I can claim to conform to that in the following.

The use case is as follows:

private static void ValidationTest()
n)e Street$", "Street Name doesn't conform to the pattern");

 DoTheValidation(validator, Tester);


private static void ValidationTestDefaultErrorMessages()
n)e Street$", null);

 DoTheValidation(validator, Tester);


private static void DoTheValidation<T>(Validator<T> validator, T source)

 var result = source.ValidateWith(validator);

 Console.WriteLine("The following Errors were found: ");
 foreach (ValidateResult<T> failure in result.Where(r => (r as Success<T>) is null))
 
 Console.WriteLine(failure);
 


private class Person

 public string FirstName get; set; 

 public string LastName get; set; 

 public Address Address get; set; 

 public int Age get; set; 


private class Address

 public string Street get; set; 


private static readonly Person Tester = new Person

 FirstName = "Cookie",
 LastName = "Monster",
 Age = 45,
 Address = new Address
 
 Street = "Sesame Street"
 
;

As shown, it's possible to add validation rules in an easy fluent manner.

The ValidationStopConditions is defined as:

 public enum ValidationStopConditions
 
 RunAll = 1,
 StopOnFailure = 2,
 StopOnWarning = 3
 

and determines if all rules should be run no matter what happens or if the validation stops on first failure or warning.

The Validator class looks like:

 public static class Validator
 
 public static Validator<TSource> For<TSource>(ValidationStopConditions stopCondition = ValidationStopConditions.RunAll) => new Validator<TSource>(stopCondition);
 

 public class Validator<T>
 
 List<Func<T, ValidateResult<T>>> m_rules = new List<Func<T, ValidateResult<T>>>();

 public Validator(ValidationStopConditions stopCondition)
 
 StopCondition = stopCondition;
 

 public ValidationStopConditions StopCondition get; 

 public IReadOnlyList<ValidateResult<T>> Validate(T source)
 
 if (source == null) return Enumerable.Empty<ValidateResult<T>>().ToList();

 switch (StopCondition)
 
 case ValidationStopConditions.RunAll:
 return m_rules.Select(rule => rule(source)).ToList();
 case ValidationStopConditions.StopOnFailure:
 
 List<ValidateResult<T>> results = new List<ValidateResult<T>>();
 foreach (var rule in m_rules)
 
 var result = rule(source);
 results.Add(result);
 if (result is Failure<T>)
 return results;
 
 return results;
 
 case ValidationStopConditions.StopOnWarning:
 
 List<ValidateResult<T>> results = new List<ValidateResult<T>>();
 foreach (var rule in m_rules)
 
 var result = rule(source);
 results.Add(result);
 if (result is Warning<T>)
 return results;
 
 return results;
 
 default:
 throw new InvalidOperationException($"Invalid Stop Condition: StopCondition");
 
 

 internal void AddRule(Predicate<T> predicate, string errorMessage)
 
 Func<T, ValidateResult<T>> rule = source =>
 
 if (predicate(source))
 return new Success<T>(source);
 return new Failure<T>(source, errorMessage);
 ;
 m_rules.Add(rule);
 

 internal void AddWarning(Predicate<T> predicate, string warningMessage)
 
 Func<T, ValidateResult<T>> rule = source =>
 
 if (predicate(source))
 return new Success<T>(source);
 return new Warning<T>(source, warningMessage);
 ;
 m_rules.Add(rule);
 
 

And the rules are defined as extension methods as:

 public static class ValidationRules
 
 // Helper method - not a rule
 private static string GetDefaultMessage(this Expression expression, string format)
 
 ValidateExpressionVisitor visitor = new ValidateExpressionVisitor();
 visitor.Visit(expression);

 return string.Format(format, visitor.Message);
 

 public static Validator<T> NotNull<T, TMember>(this Validator<T> validator, Expression<Func<T, TMember>> expression, string errorMessage)
 
 errorMessage = errorMessage ?? expression.GetDefaultMessage("0 is null");

 var getter = expression.Compile();
 Predicate<T> predicate = source => getter(source) != null;
 validator.AddRule(predicate, errorMessage);
 return validator;
 

 public static Validator<T> MustBeNull<T, TMember>(this Validator<T> validator, Expression<Func<T, TMember>> expression, string errorMessage)
 
 errorMessage = errorMessage ?? expression.GetDefaultMessage("0 is not null");

 var getter = expression.Compile();
 Predicate<T> predicate = source => getter(source) == null;
 validator.AddRule(predicate, errorMessage);
 return validator;
 

 public static Validator<T> IsTrue<T>(this Validator<T> validator, Expression<Predicate<T>> predicate, string errorMessage)
 
 errorMessage = errorMessage ?? predicate.GetDefaultMessage("0 is not true");

 validator.AddRule(predicate.Compile(), errorMessage);
 return validator;
 

 public static Validator<T> WarnIfTrue<T>(this Validator<T> validator, Expression<Predicate<T>> predicate, string message)
 
 message = message ?? predicate.GetDefaultMessage("0 is true");

 validator.AddWarning(src => !predicate.Compile()(src), message);
 return validator;
 

 public static Validator<T> IsFalse<T>(this Validator<T> validator, Expression<Predicate<T>> predicate, string errorMessage)
 
 errorMessage = errorMessage ?? predicate.GetDefaultMessage("0 is not false");

 validator.AddRule(src => !predicate.Compile()(src), errorMessage);
 return validator;
 

 public static Validator<T> WarnIfFalse<T>(this Validator<T> validator, Expression<Predicate<T>> predicate, string message)
 
 message = message ?? predicate.GetDefaultMessage("0 is false");

 validator.AddWarning(predicate.Compile(), message);
 return validator;
 

 public static Validator<T> Match<T>(this Validator<T> validator, Expression<Func<T, string>> expression, string pattern, string errorMessage)
 
 errorMessage = errorMessage ?? $@"expression.GetDefaultMessage("") doesn't match pattern: ""pattern""";

 var getter = expression.Compile();
 Predicate<T> predicate = source => Regex.IsMatch(getter(source), pattern);
 validator.AddRule(predicate, errorMessage);
 return validator;
 
 

New rules can easily be added when needed.

The result of each validation can either be Success<T>, Warning<T> or Failure<T>:

 public abstract class ValidateResult<T>
 
 public ValidateResult(T source)
 
 Source = source;
 

 public T Source get; 
 

 public class Success<T> : ValidateResult<T>
 
 public Success(T source) : base(source)
 
 

 public override string ToString()
 
 return "Everything is OK";
 
 

 public class Failure<T> : ValidateResult<T>
 
 public Failure(T source, string message) : base(source)
 
 Message = message;
 

 public string Message get; 

 public override string ToString()
 
 return $"Error: Message";
 
 

 public class Warning<T> : ValidateResult<T>
 
 public Warning(T source, string message) : base(source)
 
 Message = message;
 

 public string Message get; 

 public override string ToString()
 
 return $"Warning: Message";
 
 

The message member of Warning and Failure will be either the provided message argument to the rule or an auto generated default.

A convenient api:

 public static class ValidationExtensions
 
 public static IReadOnlyList<ValidateResult<T>> ValidateWith<T>(this T source, Validator<T> validator)
 
 if (source == null) throw new ArgumentNullException(nameof(source));
 if (validator == null) throw new ArgumentNullException(nameof(validator));

 return validator.Validate(source);
 
 

The default error/warning messages are found using a simple ExpressionVisitor:

 internal class ValidateExpressionVisitor : ExpressionVisitor
 
 public ValidateExpressionVisitor()
 
 

 public string Message get; private set; 

 protected override Expression VisitLambda<T>(Expression<T> node)
 
 Message = node.Body.ToString();

 return base.VisitLambda(node);
 
 

This is very basic, and is intended only for test, development and debugging.

Any comments are welcome.

This API does feel fluent for consumers to use.
You have also included some features I missed in the post you were inspired by.

• various severity levels [warning, error]


• custom error messages (although t3chb0t did comment he was working on this)

What I'm still missing is a way to throw an exception if I want to. Currently, your API is a sand-box. You could foresee ThrowOnError and ThrowOnWarning. Perhaps also with overloads that take an exception type. If multiple errors/warnings are found, they should be wrapped in an AggregateException.

private static void DoTheValidation<T>(Validator<T> validator, T source)

 var result = source.ValidateWith(validator).ThrowOnError().Result;

Fluent API

Fluent APIs are generally very useful but one has to be very careful with them as there is a chance of making them overfluent. This means that you try to create an API for every possible combination like:

 var validator = Validator.For<Person>(ValidationStopConditions.RunAll)
 .WarnIfTrue(p => p.Age > 50, "Person is older than 50")
 .WarnIfFalse(p => p.Age < 50, "Person is older than 50")
 .NotNull(p => p.LastName, "LastName is null")
 .MustBeNull(p => p.LastName, "LastName should be null")
 .IsTrue(p => p.FirstName.Length > 3, "First Name is too short")
 .IsFalse(p => p.FirstName.StartsWith("Cos"), "First Name starts with Coo")
 .Match(p => p.Address.Street, @"^Sesa(m|n)e Street$", "Street Name doesn't conform to the pattern");

Instead, I think it's better to make them composable so that end-users have the freedom of creating expressions not anticipated by the API creator. (I made this mistake in my utility too (by having Null and NotNull instead of using a modifier) so I have redesigned it since).

This would both reduce the number of available APIs and the learning curve for the end-user and make also coding and testing easier because there would be much less combinations.

Consider this:

Validator
 .For<Person>()
 .True(p => p.Age > 50)
 // then modifiers can be chained...
 .Exclude() // <- or Exclude/Not/Negate etc,
 .Require() // <- upgrades this check to yield an error instead of a warning

Without such modifiers like Exclude/Not or Warn you would need to create these versions for each and every rule. Then you add a new one... and you can create it three or four times again. Now, what happens if you create a new modifier? You'll have to create even more versions of all existing APIs. You would end up with so many of them...

Consistency

There should be more consistency between the APIs. So, when there is MustBeNull then there should also be MustBeTrue instead of just IsTrue, etc.

Validation levels

I like that idea of having results other than just black-n-white but also a gray Warning inbetween. This opens a bunch of whole new possibilities such as fixing property values.

Handling validations

I think the first switch is (might be) dagerous:

 public enum ValidationStopConditions
 
 RunAll = 1,
 StopOnFailure = 2,
 StopOnWarning = 3
 

I haven't exactly analyzed how rules are handled but it might crash when person.FirstName is null and later person.FirstName > 3 is used. The idea of having Error rule was to break here because it's pointless to check other conditions that rely on that one. This should signal an unrecoverable validation error. But I guess it just yields through all other rules (according to ROP).

Creating & compiling expressions

Expressions can be very tricky but they are at the same time super useful for generating error messages and it's nice to see that model here too. However some of them are less useful than other. Let's take a look at this one:

 var getter = expression.Compile();
 Predicate<T> predicate = source => Regex.IsMatch(getter(source), pattern);

The generated expression string won't show the Regex.IsMatch because it's not part of the expression. Unless it's by design, I suggest the follwing approach (taken from my new APIs). Here, you build a new expression containing all calls so that they are rendered into the final string.

 public static LambdaExpression Match<T>(Expression<Func<T, string>> expression, string pattern, RegexOptions options)
 
 var isMatchMethod = typeof(Regex).GetMethod(nameof(Regex.IsMatch), new [] typeof(string), typeof(string), typeof(RegexOptions) );
 return
 Expression.Lambda(
 Expression.Call(
 isMatchMethod,
 expression.Body,
 Expression.Constant(pattern),
 Expression.Constant(options)),
 expression.Parameters
 );
 

Naming

I would rename the ValidateExpressionVisitor to something more intuitive like ValidationMessageCreator. It doesn't have to have the Visitor ending as it rarely fits into what a visitor is actually doing. I suggest dropping that suffix.