Move internal publicly exposed properties and methods on FluentValidation into single exposed property with type Internal.

CodingFlow · CodingFlow · commit 17cee68d7108 · 2026-01-04T22:23:38.000-05:00
diff --git a/CodingFlow.FluentValidation.UnitTests/TestValidators.cs b/CodingFlow.FluentValidation.UnitTests/TestValidators.cs
@@ -8,7 +8,7 @@ public static class TestValidators
     {
         public FluentValidation<T> Valid()
         {
-            validation.Validate(
+            validation.Internal.Validate(
                 _ => true,
                 new() { Message = ErrorMessage }
             );
@@ -18,7 +18,7 @@ public FluentValidation<T> Valid()
 
         public FluentValidation<T> Invalid()
         {
-            validation.Validate(
+            validation.Internal.Validate(
                 _ => false,
                 new() { Message = ErrorMessage }
             );
diff --git a/CodingFlow.FluentValidation/FluentValidation.cs b/CodingFlow.FluentValidation/FluentValidation.cs
@@ -6,52 +6,23 @@
 /// <typeparam name="T">Input type.</typeparam>
 public class FluentValidation<T>
 {
-    public T Input { get; set; }
     public ValidationResult Result { get; set; }
 
     public List<ValidationError> Errors { get; init; } = [];
 
-    public ValidationError LastError { get; private set; }
+    /// <summary>
+    /// Used internally by the library. Do not use this property
+    /// unless you are building your own validator.
+    /// </summary>
+    public Internal<T> Internal { get; private set; }
 
     public FluentValidation(T input)
     {
-        Input = input;
         Result = new() { Errors = Errors };
-    }
-
-    public void AddValid()
-    {
-        LastError = default;
-    }
-
-    public void AddError(ValidationError error)
-    {
-        Result.IsValid = false;
-        LastError = error;
-        Errors.Add(error);
-    }
-
-    public void Validate(Func<FluentValidation<T>, bool> validator, ValidationError error)
-    {
-        if (validator(this))
-        {
-            AddValid();
-        }
-        else
-        {
-            AddError(error);
-        }
-    }
-
-    public void ChangeErrorMessage(string message)
-    {
-        if (LastError != default)
+        
+        Internal = new Internal<T>(this)
         {
-            Errors.RemoveAt(Errors.Count - 1);
-            Errors.Add(LastError with
-            {
-                Message = message
-            });
-        }
+            Input = input
+        };
     }
 }
diff --git a/CodingFlow.FluentValidation/Internal.cs b/CodingFlow.FluentValidation/Internal.cs
@@ -0,0 +1,44 @@
+﻿namespace CodingFlow.FluentValidation;
+
+public class Internal<T>(FluentValidation<T> validation)
+{
+    public required T Input { get; set; }
+
+    public ValidationError LastError { get; private set; }
+
+    public void AddValid()
+    {
+        LastError = default;
+    }
+
+    public void AddError(ValidationError error)
+    {
+        validation.Result.IsValid = false;
+        LastError = error;
+        validation.Errors.Add(error);
+    }
+
+    public void Validate(Func<FluentValidation<T>, bool> validator, ValidationError error)
+    {
+        if (validator(validation))
+        {
+            AddValid();
+        }
+        else
+        {
+            AddError(error);
+        }
+    }
+
+    public void ChangeErrorMessage(string message)
+    {
+        if (LastError != default)
+        {
+            validation.Errors.RemoveAt(validation.Errors.Count - 1);
+            validation.Errors.Add(LastError with
+            {
+                Message = message
+            });
+        }
+    }
+}
diff --git a/CodingFlow.FluentValidation/Validators/BetweenExclusiveValidator.cs b/CodingFlow.FluentValidation/Validators/BetweenExclusiveValidator.cs
@@ -24,9 +24,9 @@ public static FluentValidation<T> BetweenExclusive<T>(this FluentValidation<T> v
     private static void Validate<T>(FluentValidation<T> validation, T minimum, T maximum)
         where T : INumber<T>
     {
-        validation.Validate(
-            validation => minimum < validation.Input && validation.Input < maximum,
-            new ValidationError($"Value '{validation.Input}' of type {typeof(T)} is not between {minimum} and {maximum}.")
+        validation.Internal.Validate(
+            validation => minimum < validation.Internal.Input && validation.Internal.Input < maximum,
+            new ValidationError($"Value '{validation.Internal.Input}' of type {typeof(T)} is not between {minimum} and {maximum}.")
         );
     }
 }
diff --git a/CodingFlow.FluentValidation/Validators/BetweenInclusiveValidator.cs b/CodingFlow.FluentValidation/Validators/BetweenInclusiveValidator.cs
@@ -24,9 +24,9 @@ public static FluentValidation<T> BetweenInclusive<T>(this FluentValidation<T> v
     private static void Validate<T>(FluentValidation<T> validation, T minimum, T maximum)
         where T : INumber<T>
     {
-        validation.Validate(
-            validation => minimum <= validation.Input && validation.Input <= maximum,
-            new ValidationError($"Value '{validation.Input}' of type {typeof(T)} is not equal to or between {minimum} and {maximum}.")
+        validation.Internal.Validate(
+            validation => minimum <= validation.Internal.Input && validation.Internal.Input <= maximum,
+            new ValidationError($"Value '{validation.Internal.Input}' of type {typeof(T)} is not equal to or between {minimum} and {maximum}.")
         );
     }
 }
diff --git a/CodingFlow.FluentValidation/Validators/EqualValidator.cs b/CodingFlow.FluentValidation/Validators/EqualValidator.cs
@@ -20,9 +20,9 @@ public static FluentValidation<T> Equal<T>(this FluentValidation<T> validation,
 
     private static void Validate<T>(FluentValidation<T> validation, T input)
     {
-        validation.Validate(
-            validation => validation.Input.Equals(input),
-            new ValidationError($"Value '{validation.Input}' of type {typeof(T)} is not equal to {input}.")
+        validation.Internal.Validate(
+            validation => validation.Internal.Input.Equals(input),
+            new ValidationError($"Value '{validation.Internal.Input}' of type {typeof(T)} is not equal to {input}.")
         );
     }
 }
diff --git a/CodingFlow.FluentValidation/Validators/IsGuidValidator.cs b/CodingFlow.FluentValidation/Validators/IsGuidValidator.cs
@@ -18,9 +18,9 @@ public static FluentValidation<string> IsGuid(this FluentValidation<string> vali
 
     private static void Validate(FluentValidation<string> validation)
     {
-        validation.Validate(
-            validation => Guid.TryParse(validation.Input, out var value),
-            new ValidationError($"Value '{validation.Input}' is not a valid GUID.")
+        validation.Internal.Validate(
+            validation => Guid.TryParse(validation.Internal.Input, out var value),
+            new ValidationError($"Value '{validation.Internal.Input}' is not a valid GUID.")
         );
     }
 }
diff --git a/CodingFlow.FluentValidation/Validators/MatchesValidator.cs b/CodingFlow.FluentValidation/Validators/MatchesValidator.cs
@@ -21,9 +21,9 @@ public static FluentValidation<string> Matches(this FluentValidation<string> val
 
     private static void Validate(FluentValidation<string> validation, string regex)
     {
-        validation.Validate(
-            validation => Regex.IsMatch(validation.Input, regex),
-            new ValidationError($"Value '{validation.Input}' does not match the pattern.")
+        validation.Internal.Validate(
+            validation => Regex.IsMatch(validation.Internal.Input, regex),
+            new ValidationError($"Value '{validation.Internal.Input}' does not match the pattern.")
         );
     }
 }
diff --git a/CodingFlow.FluentValidation/Validators/MaximumLengthValidator.cs b/CodingFlow.FluentValidation/Validators/MaximumLengthValidator.cs
@@ -19,9 +19,9 @@ public static FluentValidation<string> MaximumLength(this FluentValidation<strin
 
     private static void Validate(FluentValidation<string> validation, int maximum)
     {
-        validation.Validate(
-            validation => validation.Input.Length <= maximum,
-            new ValidationError($"Value '{validation.Input}' has a length more than {maximum}.")
+        validation.Internal.Validate(
+            validation => validation.Internal.Input.Length <= maximum,
+            new ValidationError($"Value '{validation.Internal.Input}' has a length more than {maximum}.")
         );
     }
 }
diff --git a/CodingFlow.FluentValidation/Validators/MinimumLengthValidator.cs b/CodingFlow.FluentValidation/Validators/MinimumLengthValidator.cs
@@ -19,9 +19,9 @@ public static FluentValidation<string> MinimumLength(this FluentValidation<strin
 
     private static void Validate(FluentValidation<string> validation, int minimum)
     {
-        validation.Validate(
-            validation => validation.Input.Length >= minimum,
-            new ValidationError($"Value '{validation.Input}' has a length less than {minimum}.")
+        validation.Internal.Validate(
+            validation => validation.Internal.Input.Length >= minimum,
+            new ValidationError($"Value '{validation.Internal.Input}' has a length less than {minimum}.")
         );
     }
 }
diff --git a/CodingFlow.FluentValidation/Validators/MustValidator.cs b/CodingFlow.FluentValidation/Validators/MustValidator.cs
@@ -19,9 +19,9 @@ public static FluentValidation<T> Must<T>(this FluentValidation<T> validation, F
 
     private static void Validate<T>(FluentValidation<T> validation, Func<T, bool> predicate)
     {
-        validation.Validate(
-            validation => predicate(validation.Input),
-            new ValidationError($"Value '{validation.Input}' of type {typeof(T)} is not valid.")
+        validation.Internal.Validate(
+            validation => predicate(validation.Internal.Input),
+            new ValidationError($"Value '{validation.Internal.Input}' of type {typeof(T)} is not valid.")
         );
     }
 }
diff --git a/CodingFlow.FluentValidation/Validators/NotEmptyValidator.cs b/CodingFlow.FluentValidation/Validators/NotEmptyValidator.cs
@@ -18,17 +18,17 @@ public static FluentValidation<T> NotEmpty<T>(this FluentValidation<T> validatio
 
     private static void Validate<T>(FluentValidation<T> validation)
     {
-        validation.Validate(
+        validation.Internal.Validate(
             validation =>
             {
                 if (typeof(T) == typeof(string))
                 {
-                    return !string.IsNullOrWhiteSpace(validation.Input as string);
+                    return !string.IsNullOrWhiteSpace(validation.Internal.Input as string);
                 }
 
-                return !EqualityComparer<T>.Default.Equals(validation.Input, default);
+                return !EqualityComparer<T>.Default.Equals(validation.Internal.Input, default);
             },
-            new ValidationError($"Value '{validation.Input}' of type {typeof(T)} is empty.")
+            new ValidationError($"Value '{validation.Internal.Input}' of type {typeof(T)} is empty.")
         );
     }
 }
diff --git a/CodingFlow.FluentValidation/WithMessage.cs b/CodingFlow.FluentValidation/WithMessage.cs
@@ -11,7 +11,7 @@ public static class WithExtensions
     /// <returns></returns>
     public static FluentValidation<T> WithMessage<T>(this FluentValidation<T> validation, string message)
     {
-        validation.ChangeErrorMessage(message);
+        validation.Internal.ChangeErrorMessage(message);
 
         return validation;
     }

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ public static class TestValidators`
`8`	`8`	`{`
`9`	`9`	`public FluentValidation<T> Valid()`
`10`	`10`	`{`
`11`		`- validation.Validate(`
	`11`	`+ validation.Internal.Validate(`
`12`	`12`	`_ => true,`
`13`	`13`	`new() { Message = ErrorMessage }`
`14`	`14`	`);`
`@@ -18,7 +18,7 @@ public FluentValidation<T> Valid()`
`18`	`18`
`19`	`19`	`public FluentValidation<T> Invalid()`
`20`	`20`	`{`
`21`		`- validation.Validate(`
	`21`	`+ validation.Internal.Validate(`
`22`	`22`	`_ => false,`
`23`	`23`	`new() { Message = ErrorMessage }`
`24`	`24`	`);`
Original file line number	Diff line number	Diff line change
`@@ -24,9 +24,9 @@ public static FluentValidation<T> BetweenExclusive<T>(this FluentValidation<T> v`
`24`	`24`	`private static void Validate<T>(FluentValidation<T> validation, T minimum, T maximum)`
`25`	`25`	`where T : INumber<T>`
`26`	`26`	`{`
`27`		`- validation.Validate(`
`28`		`- validation => minimum < validation.Input && validation.Input < maximum,`
`29`		`- new ValidationError($"Value '{validation.Input}' of type {typeof(T)} is not between {minimum} and {maximum}.")`
	`27`	`+ validation.Internal.Validate(`
	`28`	`+ validation => minimum < validation.Internal.Input && validation.Internal.Input < maximum,`
	`29`	`+ new ValidationError($"Value '{validation.Internal.Input}' of type {typeof(T)} is not between {minimum} and {maximum}.")`
`30`	`30`	`);`
`31`	`31`	`}`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,9 +20,9 @@ public static FluentValidation<T> Equal<T>(this FluentValidation<T> validation,`
`20`	`20`
`21`	`21`	`private static void Validate<T>(FluentValidation<T> validation, T input)`
`22`	`22`	`{`
`23`		`- validation.Validate(`
`24`		`- validation => validation.Input.Equals(input),`
`25`		`- new ValidationError($"Value '{validation.Input}' of type {typeof(T)} is not equal to {input}.")`
	`23`	`+ validation.Internal.Validate(`
	`24`	`+ validation => validation.Internal.Input.Equals(input),`
	`25`	`+ new ValidationError($"Value '{validation.Internal.Input}' of type {typeof(T)} is not equal to {input}.")`
`26`	`26`	`);`
`27`	`27`	`}`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,9 +18,9 @@ public static FluentValidation<string> IsGuid(this FluentValidation<string> vali`
`18`	`18`
`19`	`19`	`private static void Validate(FluentValidation<string> validation)`
`20`	`20`	`{`
`21`		`- validation.Validate(`
`22`		`- validation => Guid.TryParse(validation.Input, out var value),`
`23`		`- new ValidationError($"Value '{validation.Input}' is not a valid GUID.")`
	`21`	`+ validation.Internal.Validate(`
	`22`	`+ validation => Guid.TryParse(validation.Internal.Input, out var value),`
	`23`	`+ new ValidationError($"Value '{validation.Internal.Input}' is not a valid GUID.")`
`24`	`24`	`);`
`25`	`25`	`}`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,9 +21,9 @@ public static FluentValidation<string> Matches(this FluentValidation<string> val`
`21`	`21`
`22`	`22`	`private static void Validate(FluentValidation<string> validation, string regex)`
`23`	`23`	`{`
`24`		`- validation.Validate(`
`25`		`- validation => Regex.IsMatch(validation.Input, regex),`
`26`		`- new ValidationError($"Value '{validation.Input}' does not match the pattern.")`
	`24`	`+ validation.Internal.Validate(`
	`25`	`+ validation => Regex.IsMatch(validation.Internal.Input, regex),`
	`26`	`+ new ValidationError($"Value '{validation.Internal.Input}' does not match the pattern.")`
`27`	`27`	`);`
`28`	`28`	`}`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,9 +19,9 @@ public static FluentValidation<string> MaximumLength(this FluentValidation<strin`
`19`	`19`
`20`	`20`	`private static void Validate(FluentValidation<string> validation, int maximum)`
`21`	`21`	`{`
`22`		`- validation.Validate(`
`23`		`- validation => validation.Input.Length <= maximum,`
`24`		`- new ValidationError($"Value '{validation.Input}' has a length more than {maximum}.")`
	`22`	`+ validation.Internal.Validate(`
	`23`	`+ validation => validation.Internal.Input.Length <= maximum,`
	`24`	`+ new ValidationError($"Value '{validation.Internal.Input}' has a length more than {maximum}.")`
`25`	`25`	`);`
`26`	`26`	`}`
`27`	`27`	`}`