Update from main.

CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.9.0
+
+- Added quick validation support via `QuickValidator` and its `Validate<T>` overloads.
+- Improve performance by applying options in `ExpressValidator<TObj, TOptions>` during the `ExpressValidatorBuilder<TObj, TOptions>.Build` call instead of at validation time.
+- Introduce the `Unit` readonly struct.
+- Add 'Nuances Of Using The Library' README Chapter.
+- Add 'Nuances Of Using The Library' NuGet README Chapter.
+- Add 'Quick Validation' README Chapter.
+- Add 'Quick Validation' NuGet README Chapter.
+
+
 ## 0.5.0
 
 - Introduced the `IExpressValidatorBuilder<TObj, TOptions>.BuildAndValidate<TObj, TOptions>(TObj, TOptions)` extension method.

README.md

@@ -18,6 +18,7 @@ ExpressValidator is a library that provides the ability to validate objects usin
 - Supports adding a property or field for validation.
 - Verifies that a property expression is a property and a field expression is a field, and throws `ArgumentException` if it is not.
 - Supports adding a `Func` that provides a value for validation.
+- Provides quick validation (refers to ease of use).
 - Supports asynchronous validation.
 - Targets .NET Standard 2.0+
 
@@ -129,6 +130,49 @@ if(!result2.IsValid)
 }
 ```
 
+## ⏩ Quick Validation
+
+Quick validation is convenient for primitive types or types without properties/fields (here, 'quick' refers to usability, not performance). Simply call `QuickValidator.Validate` on the object with a preconfigured rule:
+
+```csharp
+var value = 5;
+// result.IsValid == false
+// result.Errors[0].PropertyName == "value"
+var result = QuickValidator.Validate(
+	value,
+	(opt) => opt.GreaterThan(10),
+	nameof(value));
+```
+
+For complex types, use FluentValidation's `ChildRules` method:
+
+```csharp
+var obj = new ObjToValidate() { I = -1, PercentValue1 = 101 };
+// result.IsValid == false
+// result.Errors.Count == 2
+// result.Errors[0].PropertyName == "obj.I"; result.Errors[1].PropertyName == "obj.PercentValue1"
+var result = QuickValidator.Validate(
+	obj,
+	(opt) =>
+		opt
+		.ChildRules((v) => v.RuleFor(o => o.I).GreaterThan(0))
+		.ChildRules((v) => v.RuleFor(o => o.PercentValue1).InclusiveBetween(0, 100)),
+	nameof(obj));
+```
+
+## 🧩 Nuances Of Using The Library
+
+For `ExpressValidatorBuilder` methods (`AddFunc`, `AddProperty`, and `AddField`), the overridden property name (set via  `FluentValidation`'s `OverridePropertyName` method in `With(Async)Validation`) takes precedence over the property name passed as a string or via `Expression` in  `AddFunc`/`AddProperty`/`AddField`.  
+For example, for the `ObjToValidate` object from the 'Quick Start' chapter, `result.Errors[0].PropertyName` will equal "percentSum" (the property name overridden in the validation rule):
+```csharp
+// result.Errors[0].PropertyName == "percentSum"
+var result = new ExpressValidatorBuilder<ObjToValidate>()
+		.AddFunc(o => o.PercentValue1 + o.PercentValue2, "sum")
+		.WithValidation((o) => o.InclusiveBetween(0, 100)
+			.OverridePropertyName("percentSum"))
+		.BuildAndValidate(new ObjToValidate() { PercentValue1 = 200});
+```
+
 ## ❌ Drawbacks
 
 - Non-canonical way of using of FluentValidation.

src/ExpressValidator.Extensions.DependencyInjection/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.3.5
+
+- Reduced unnecessary updates to validator parameters by listening to `IOptionsMonitor.Change` with named validation options.
+- Update 'ExpressValidator.Extensions.DependencyInjection' to ExpressValidator 0.5.0.
+- Update Microsoft nuget packages.
+- Update README with a libraries/dependencies table.
+- Add a configuration section in 'ExpressValidator.Extensions.DependencyInjection.Sample' for testing purposes.
+
+
 ## 0.3.2
 
 - Update to ExpressValidator 0.2.0.

src/ExpressValidator.Extensions.DependencyInjection/ExpressValidator.Extensions.DependencyInjection.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-    <Version>0.3.2</Version>
+    <Version>0.3.5</Version>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <Authors>Andrey Kolesnichenko</Authors>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
@@ -15,7 +15,7 @@
     <PackageTags>FluentValidation Validation DependencyInjection</PackageTags>
     <Description>The ExpressValidator.Extensions.DependencyInjection package extends ExpressValidator to provide integration with Microsoft Dependency Injection.</Description>
     <Copyright>Copyright 2024 Andrey Kolesnichenko</Copyright>
-    <AssemblyVersion>0.3.2.0</AssemblyVersion>
+    <AssemblyVersion>0.3.5.0</AssemblyVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">

src/ExpressValidator/ExpressValidator.TOptions.cs

@@ -14,15 +14,18 @@ namespace ExpressValidator
 	/// <typeparam name="TOptions"></typeparam>
 	public class ExpressValidator<TObj, TOptions> : IExpressValidator<TObj>
 	{
-		private readonly TOptions _options;
 		private readonly IEnumerable<IObjectValidator<TObj, TOptions>> _validators;
 		private readonly OnFirstPropertyValidatorFailed _validationMode;
 
 		internal ExpressValidator(TOptions options, IEnumerable<IObjectValidator<TObj, TOptions>> validators, OnFirstPropertyValidatorFailed validationMode)
 		{
-			_options = options;
 			_validators = validators;
 			_validationMode = validationMode;
+
+			foreach (var validator in _validators)
+			{
+				validator.ApplyOptions(options);
+			}
 		}
 
 		public ValidationResult Validate(TObj obj)
@@ -44,8 +47,6 @@ private async Task<ValidationResult> ValidateWithBreakAsync(TObj obj, Cancellati
 			foreach (var validator in _validators)
 			{
 				token.ThrowIfCancellationRequested();
-
-				validator.ApplyOptions(_options);
 				var (IsValid, Failures) = await validator.ValidateAsync(obj, token).ConfigureAwait(false);
 				if (!IsValid)
 				{
@@ -61,8 +62,6 @@ private async Task<ValidationResult> ValidateWithContinueAsync(TObj obj, Cancell
 			foreach (var validator in _validators)
 			{
 				token.ThrowIfCancellationRequested();
-
-				validator.ApplyOptions(_options);
 				var (IsValid, Failures) = await validator.ValidateAsync(obj, token);
 				if (!IsValid)
 				{
@@ -76,7 +75,6 @@ private ValidationResult ValidateWithBreak(TObj obj)
 		{
 			foreach (var validator in _validators)
 			{
-				validator.ApplyOptions(_options);
 				var (IsValid, Failures) = validator.Validate(obj);
 				if (!IsValid)
 				{
@@ -91,7 +89,6 @@ private ValidationResult ValidateWithContinue(TObj obj)
 			var currentFailures = new List<ValidationFailure>();
 			foreach (var validator in _validators)
 			{
-				validator.ApplyOptions(_options);
 				var (IsValid, Failures) = validator.Validate(obj);
 				if (!IsValid)
 				{

src/ExpressValidator/ExpressValidator.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-    <Version>0.5.0</Version>
+    <Version>0.9.0</Version>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <Authors>Andrey Kolesnichenko</Authors>
     <Description>ExpressValidator is a library that provides the ability to validate objects using the FluentValidation library, but without object inheritance from `AbstractValidator`.</Description>
@@ -15,7 +15,7 @@
     <PackageIcon>ExpressValidator.png</PackageIcon>
     <PackageReadmeFile>NuGet.md</PackageReadmeFile>
     <PackageIconUrl />
-    <AssemblyVersion>0.5.0.0</AssemblyVersion>
+    <AssemblyVersion>0.9.0.0</AssemblyVersion>
     <FileVersion>0.0.0.0</FileVersion>
   </PropertyGroup>
 

src/ExpressValidator/PropertyValidators/ExpressPropertyValidator.TOptions.cs

@@ -11,6 +11,7 @@ internal class ExpressPropertyValidator<TObj, TOptions, T> : IExpressPropertyVal
 	{
 		private readonly string _propName;
 		private readonly Func<TObj, T> _propertyFunc;
+		private TypeValidatorBase<T> _typeValidator;
 
 		private Action<TOptions, IRuleBuilderOptions<T, T>> _actionWithOptions;
 
@@ -30,9 +31,7 @@ public void SetValidation(Action<TOptions, IRuleBuilderOptions<T, T>> action)
 
 		public Task<(bool IsValid, List<ValidationFailure> Failures)> ValidateAsync(TObj obj, CancellationToken token = default)
 		{
-			var typeValidator = new TypeAsyncValidator<T>();
-			typeValidator.SetValidation(_action, _propName);
-			return typeValidator.ValidateExAsync(_propertyFunc(obj), token);
+			return _typeValidator.ValidateExAsync(_propertyFunc(obj), token);
 		}
 
 		public (bool IsValid, List<ValidationFailure> Failures) Validate(TObj obj)
@@ -41,14 +40,26 @@ public void SetValidation(Action<TOptions, IRuleBuilderOptions<T, T>> action)
 			{
 				throw new InvalidOperationException();
 			}
-			var typeValidator = new TypeValidator<T>();
-			typeValidator.SetValidation(_action, _propName);
-			return typeValidator.ValidateEx(_propertyFunc(obj));
+			return _typeValidator.ValidateEx(_propertyFunc(obj));
 		}
 
 		public void ApplyOptions(TOptions options)
 		{
 			_action =_actionWithOptions.Apply(options);
+			SetTypeValidator();
+		}
+
+		private void SetTypeValidator()
+		{
+			if (IsAsync)
+			{
+				_typeValidator = new TypeAsyncValidator<T>();
+			}
+			else
+			{
+				_typeValidator = new TypeValidator<T>();
+			}
+			_typeValidator.SetValidation(_action, _propName);
 		}
 
 		public bool IsAsync { get; }

src/ExpressValidator/QuickValidation/PropertyNameMode.cs

@@ -0,0 +1,18 @@
+namespace ExpressValidator.QuickValidation
+{
+    /// <summary>
+    /// Determines how the property name is set when quick validation fails.
+    /// </summary>
+    public enum PropertyNameMode
+    {
+        /// <summary>
+        /// Use the literal string "Input" as the property name.
+        /// </summary>
+        Default,
+
+        /// <summary>
+        /// Use the type's name (typeof(T).Name) of the validated object as the property name.
+        /// </summary>
+        TypeName
+    }
+}

src/ExpressValidator/QuickValidation/QuickValidator.cs

@@ -0,0 +1,57 @@
+using ExpressValidator.Extensions;
+using FluentValidation;
+using FluentValidation.Results;
+using System;
+
+namespace ExpressValidator.QuickValidation
+{
+	/// <summary>
+	/// Provides methods for quick validation.
+	/// </summary>
+	public static class QuickValidator
+	{
+		private const string FALLBACK_PROP_NAME = "Input";
+
+		/// <summary>
+		/// Validates the given object instance using <paramref name="action"/>.
+		/// </summary>
+		/// <typeparam name="T">The type of the object to validate.</typeparam>
+		/// <param name="obj">The object to validate.</param>
+		/// <param name="action">Action to add validators.</param>
+		/// <param name="propName">The name of the property if the validation fails.
+		/// If <see langword="null"/>, "Input" will be used.</param>
+		/// <param name="onSuccessValidation">Specifies a method to execute when validation succeeds.</param>
+		/// <returns></returns>
+		public static ValidationResult Validate<T>(T obj, Action<IRuleBuilderOptions<T, T>> action, string propName, Action<T> onSuccessValidation = null)
+		{
+			return ValidateInner<T>(obj, action, propName ?? FALLBACK_PROP_NAME, onSuccessValidation);
+		}
+
+		/// <summary>
+		/// Validates the given object instance using <paramref name="action"/>.
+		/// </summary>
+		/// <typeparam name="T">The type of the object to validate.</typeparam>
+		/// <param name="obj">The object to validate.</param>
+		/// <param name="action">Action to add validators.</param>
+		/// <param name="mode"><see cref="PropertyNameMode"/>.
+		/// If <see cref="PropertyNameMode.Default"/>, "Input" will be used.</param>
+		/// <param name="onSuccessValidation">Specifies a method to execute when validation succeeds.</param>
+		/// <returns></returns>
+		public static ValidationResult Validate<T>(T obj, Action<IRuleBuilderOptions<T, T>> action, PropertyNameMode mode = PropertyNameMode.Default, Action<T> onSuccessValidation = null)
+		{
+			return ValidateInner<T>(obj, action, GetPropName<T>(mode), onSuccessValidation);
+		}
+
+		private static ValidationResult ValidateInner<T>(T obj, Action<IRuleBuilderOptions<T, T>> action, string propName, Action<T> onSuccessValidation = null)
+		{
+			var eb = new ExpressValidatorBuilder<Unit>();
+			return eb.AddFunc((_) => obj,
+								propName,
+								onSuccessValidation)
+					.WithValidation(action)
+					.BuildAndValidate(Unit.Default);
+		}
+
+		private static string GetPropName<T>(PropertyNameMode mode) => mode == PropertyNameMode.Default ? FALLBACK_PROP_NAME : typeof(T).Name;
+	}
+}

src/ExpressValidator/Unit.cs

@@ -0,0 +1,7 @@
+namespace ExpressValidator
+{
+	public readonly struct Unit
+	{
+		public static readonly Unit Default = new Unit();
+	}
+}

src/ExpressValidator/ValidatorBuilders/ExpressValidatorBuilder.cs

@@ -50,7 +50,7 @@ public IBuilderWithPropValidator<TObj, T> AddField<T>(Expression<Func<TObj, T>>
 		/// <typeparam name="T">A type of value.</typeparam>
 		/// <param name="func">Func for object</param>
 		/// <param name="propName">A name of the property if the validation failed.</param>
-		/// <param name="onSuccessValidation">Func Result Validation Success Handler</param>
+		/// <param name="onSuccessValidation">Specifies a method to execute when validation succeeds.</param>
 		/// <returns></returns>
 		public IBuilderWithPropValidator<TObj, T> AddFunc<T>(Func<TObj, T> func, string propName, Action<T> onSuccessValidation = null)
 		{

src/ExpressValidator/docs/NuGet.md

@@ -8,6 +8,7 @@ ExpressValidator is a library that provides the ability to validate objects usin
 - Supports adding a property or field for validation.
 - Verifies that a property expression is a property and a field expression is a field, and throws `ArgumentException` if it is not.
 - Supports adding a `Func` that provides a value for validation.
+- Provides quick validation (refers to ease of use).
 - Supports asynchronous validation.
 - Targets .NET Standard 2.0+
 
@@ -51,6 +52,8 @@ if(!result.IsValid)
 }
 ```
 
+## Modifying FluentValidation Validator Parameters Using Options
+
 To dynamically change the parameters of the `FluentValidation` validators:  
 
 1. Create an options object that contains the parameters of validators.  
@@ -111,3 +114,46 @@ if(!result2.IsValid)
 ...
 }
 ```
+
+## Quick Validation
+
+Quick validation is convenient for primitive types or types without properties/fields (here, 'quick' refers to usability, not performance). Simply call `QuickValidator.Validate` on the object with a preconfigured rule:
+
+```csharp
+var value = 5;
+// result.IsValid == false
+// result.Errors[0].PropertyName == "value"
+var result = QuickValidator.Validate(
+	value,
+	(opt) => opt.GreaterThan(10),
+	nameof(value));
+```
+
+For complex types, use FluentValidation's `ChildRules` method:
+
+```csharp
+var obj = new ObjToValidate() { I = -1, PercentValue1 = 101 };
+// result.IsValid == false
+// result.Errors.Count == 2
+// result.Errors[0].PropertyName == "obj.I"; result.Errors[1].PropertyName == "obj.PercentValue1"
+var result = QuickValidator.Validate(
+	obj,
+	(opt) =>
+		opt
+		.ChildRules((v) => v.RuleFor(o => o.I).GreaterThan(0))
+		.ChildRules((v) => v.RuleFor(o => o.PercentValue1).InclusiveBetween(0, 100)),
+	nameof(obj));
+```
+
+## Nuances Of Using The Library
+
+For `ExpressValidatorBuilder` methods (`AddFunc`, `AddProperty`, and `AddField`), the overridden property name (set via  `FluentValidation`'s `OverridePropertyName` method in `With(Async)Validation`) takes precedence over the property name passed as a string or via `Expression` in  `AddFunc`/`AddProperty`/`AddField`.  
+For example, for the `ObjToValidate` object from the 'Quick Start' chapter, `result.Errors[0].PropertyName` will equal "percentSum" (the property name overridden in the validation rule):
+```csharp
+// result.Errors[0].PropertyName == "percentSum"
+var result = new ExpressValidatorBuilder<ObjToValidate>()
+		.AddFunc(o => o.PercentValue1 + o.PercentValue2, "sum")
+		.WithValidation((o) => o.InclusiveBetween(0, 100)
+			.OverridePropertyName("percentSum"))
+		.BuildAndValidate(new ObjToValidate() { PercentValue1 = 200});
+```