Add comprehensive validation overloads for all CaptureIt methods

Co-authored-by: AkhmedovEhson <129420305+AkhmedovEhson@users.noreply.github.com>

Author: Copilot

src/SnapshotIt.FluentValidation/CaptureValidationExtensions.cs

@@ -115,5 +115,272 @@ public static Task<ValidationResult> ValidateAsync<T>(
         {
             return validator.ValidateAsync(input);
         }
+
+        /// <summary>
+        /// Creates new collection of captures with provided size, or recreates it with validation support
+        /// </summary>
+        /// <typeparam name="T">The type of objects that will be stored in the collection</typeparam>
+        /// <param name="snapshot">The snapshot instance</param>
+        /// <param name="size">The size of the collection</param>
+        /// <param name="validator">The FluentValidation validator for future validations</param>
+        public static void CreateWithValidation<T>(
+            this ISnapshot snapshot,
+            uint size,
+            IValidator<T> validator)
+        {
+            snapshot.Create<T>(size);
+        }
+
+        /// <summary>
+        /// Gets captured object from captures by index with validation
+        /// </summary>
+        /// <typeparam name="T">The type of object to get and validate</typeparam>
+        /// <param name="snapshot">The snapshot instance</param>
+        /// <param name="ind">The index of the object to retrieve</param>
+        /// <param name="validator">The FluentValidation validator to use</param>
+        /// <returns>The validated captured object</returns>
+        /// <exception cref="ValidationException">Thrown when the retrieved object fails validation</exception>
+        /// <exception cref="IndexOutOfRangeException">Thrown when index is out of range</exception>
+        public static T GetWithValidation<T>(
+            this ISnapshot snapshot,
+            IValidator<T> validator,
+            uint ind = 0)
+        {
+            var result = snapshot.Get<T>(ind);
+            var validationResult = validator.Validate(result);
+            
+            if (!validationResult.IsValid)
+            {
+                throw new ValidationException(validationResult.Errors);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Gets captured object from captures using expressions with validation
+        /// </summary>
+        /// <typeparam name="T">The type of object to get and validate</typeparam>
+        /// <param name="snapshot">The snapshot instance</param>
+        /// <param name="predicate">The predicate to find the object</param>
+        /// <param name="validator">The FluentValidation validator to use</param>
+        /// <returns>The validated captured object</returns>
+        /// <exception cref="ValidationException">Thrown when the retrieved object fails validation</exception>
+        /// <exception cref="NullReferenceException">Thrown when object is not found</exception>
+        public static T GetWithValidation<T>(
+            this ISnapshot snapshot,
+            Func<T, bool> predicate,
+            IValidator<T> validator)
+        {
+            var result = snapshot.Get<T>(predicate);
+            var validationResult = validator.Validate(result);
+            
+            if (!validationResult.IsValid)
+            {
+                throw new ValidationException(validationResult.Errors);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Gets captured object by index asynchronously with validation
+        /// </summary>
+        /// <typeparam name="T">The type of object to get and validate</typeparam>
+        /// <param name="snapshot">The snapshot instance</param>
+        /// <param name="ind">The index of the object to retrieve</param>
+        /// <param name="validator">The FluentValidation validator to use</param>
+        /// <returns>The validated captured object</returns>
+        /// <exception cref="ValidationException">Thrown when the retrieved object fails validation</exception>
+        public static async Task<T> GetWithValidationAsync<T>(
+            this ISnapshot snapshot,
+            int ind,
+            IValidator<T> validator)
+        {
+            var result = await snapshot.GetAsync<T>(ind);
+            var validationResult = await validator.ValidateAsync(result);
+            
+            if (!validationResult.IsValid)
+            {
+                throw new ValidationException(validationResult.Errors);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Gets all captures asynchronously with validation for each object
+        /// </summary>
+        /// <typeparam name="T">The type of objects to get and validate</typeparam>
+        /// <param name="snapshot">The snapshot instance</param>
+        /// <param name="validator">The FluentValidation validator to use</param>
+        /// <returns>Array of validated captured objects</returns>
+        /// <exception cref="ValidationException">Thrown when any retrieved object fails validation</exception>
+        public static async Task<T[]> GetAllWithValidationAsync<T>(
+            this ISnapshot snapshot,
+            IValidator<T> validator)
+        {
+            var results = await snapshot.GetAllAsync<T>();
+            var validationTasks = results.Where(r => r != null).Select(result => validator.ValidateAsync(result));
+            var validationResults = await Task.WhenAll(validationTasks);
+            
+            var allErrors = validationResults
+                .Where(result => !result.IsValid)
+                .SelectMany(result => result.Errors)
+                .ToList();
+
+            if (allErrors.Count > 0)
+            {
+                throw new ValidationException(allErrors);
+            }
+
+            return results;
+        }
+
+        /// <summary>
+        /// Gets collection of captures as Span with validation for each object
+        /// </summary>
+        /// <typeparam name="T">The type of objects to get and validate</typeparam>
+        /// <param name="snapshot">The snapshot instance</param>
+        /// <param name="validator">The FluentValidation validator to use</param>
+        /// <returns>Span of validated captured objects</returns>
+        /// <exception cref="ValidationException">Thrown when any object fails validation</exception>
+        public static Span<T> GetAsSpanWithValidation<T>(
+            this ISnapshot snapshot,
+            IValidator<T> validator)
+        {
+            var results = snapshot.GetAsSpan<T>();
+            
+            foreach (var item in results)
+            {
+                if (item != null)
+                {
+                    var validationResult = validator.Validate(item);
+                    if (!validationResult.IsValid)
+                    {
+                        throw new ValidationException(validationResult.Errors);
+                    }
+                }
+            }
+
+            return results;
+        }
+
+        /// <summary>
+        /// Gets collection of captures as ReadOnlySpan with validation for each object
+        /// </summary>
+        /// <typeparam name="T">The type of objects to get and validate</typeparam>
+        /// <param name="snapshot">The snapshot instance</param>
+        /// <param name="validator">The FluentValidation validator to use</param>
+        /// <returns>ReadOnlySpan of validated captured objects</returns>
+        /// <exception cref="ValidationException">Thrown when any object fails validation</exception>
+        public static ReadOnlySpan<T> GetAsReadonlySpanWithValidation<T>(
+            this ISnapshot snapshot,
+            IValidator<T> validator)
+        {
+            var results = snapshot.GetAsReadonlySpan<T>();
+            
+            foreach (var item in results)
+            {
+                if (item != null)
+                {
+                    var validationResult = validator.Validate(item);
+                    if (!validationResult.IsValid)
+                    {
+                        throw new ValidationException(validationResult.Errors);
+                    }
+                }
+            }
+
+            return results;
+        }
+
+        /// <summary>
+        /// Gets collection of captures as IEnumerable with validation for each object
+        /// </summary>
+        /// <typeparam name="T">The type of objects to get and validate</typeparam>
+        /// <param name="snapshot">The snapshot instance</param>
+        /// <param name="validator">The FluentValidation validator to use</param>
+        /// <returns>IEnumerable of validated captured objects</returns>
+        /// <exception cref="ValidationException">Thrown when any object fails validation</exception>
+        public static IEnumerable<T> GetAsEnumerableWithValidation<T>(
+            this ISnapshot snapshot,
+            IValidator<T> validator)
+        {
+            var results = snapshot.GetAsEnumerable<T>();
+            
+            foreach (var item in results)
+            {
+                if (item != null)
+                {
+                    var validationResult = validator.Validate(item);
+                    if (!validationResult.IsValid)
+                    {
+                        throw new ValidationException(validationResult.Errors);
+                    }
+                }
+                yield return item;
+            }
+        }
+
+        /// <summary>
+        /// Gets collection of captures as List with validation for each object
+        /// </summary>
+        /// <typeparam name="T">The type of objects to get and validate</typeparam>
+        /// <param name="snapshot">The snapshot instance</param>
+        /// <param name="validator">The FluentValidation validator to use</param>
+        /// <returns>List of validated captured objects</returns>
+        /// <exception cref="ValidationException">Thrown when any object fails validation</exception>
+        public static List<T> GetAsListWithValidation<T>(
+            this ISnapshot snapshot,
+            IValidator<T> validator)
+        {
+            var results = snapshot.GetAsList<T>();
+            
+            foreach (var item in results)
+            {
+                if (item != null)
+                {
+                    var validationResult = validator.Validate(item);
+                    if (!validationResult.IsValid)
+                    {
+                        throw new ValidationException(validationResult.Errors);
+                    }
+                }
+            }
+
+            return results;
+        }
+
+        /// <summary>
+        /// Gets collection of captures as List with size settings and validation for each object
+        /// </summary>
+        /// <typeparam name="T">The type of objects to get and validate</typeparam>
+        /// <param name="snapshot">The snapshot instance</param>
+        /// <param name="size">The size of the list</param>
+        /// <param name="validator">The FluentValidation validator to use</param>
+        /// <returns>List of validated captured objects</returns>
+        /// <exception cref="ValidationException">Thrown when any object fails validation</exception>
+        public static List<T> GetAsListWithValidation<T>(
+            this ISnapshot snapshot,
+            uint size,
+            IValidator<T> validator)
+        {
+            var results = snapshot.GetAsList<T>(size);
+            
+            foreach (var item in results)
+            {
+                if (item != null)
+                {
+                    var validationResult = validator.Validate(item);
+                    if (!validationResult.IsValid)
+                    {
+                        throw new ValidationException(validationResult.Errors);
+                    }
+                }
+            }
+
+            return results;
+        }
     }
 }

src/SnapshotIt.FluentValidation/README.md

@@ -1,13 +1,42 @@
 # SnapshotIt.FluentValidation
 
-FluentValidation integration for SnapshotIt library, providing validation capabilities for capturing objects to snapshots.
+FluentValidation integration for SnapshotIt library, providing comprehensive validation capabilities for capturing and retrieving objects to/from snapshots.
 
 ## Features
 
-- Validate objects before posting to snapshots using FluentValidation
-- Support for both synchronous and asynchronous validation
-- Validation of single objects and arrays
-- Comprehensive error handling with ValidationException
+- **Post Validation**: Validate objects before posting to snapshots using FluentValidation
+- **Get Validation**: Validate objects when retrieving from snapshots  
+- **Collection Validation**: Validate collections and arrays of objects
+- **Comprehensive Coverage**: Validation overloads for all CaptureIt methods
+- **Support for both synchronous and asynchronous validation**
+- **Comprehensive error handling with ValidationException**
+
+## Available Methods
+
+### Post Methods (with validation before storing)
+- `PostWithValidation<T>(T input, IValidator<T> validator)` - Synchronous validation before posting
+- `PostWithValidationAsync<T>(T input, IValidator<T> validator)` - Asynchronous validation before posting
+- `PostWithValidationAsync<T>(T[] values, IValidator<T> validator)` - Asynchronous validation before posting arrays
+
+### Get Methods (with validation when retrieving)
+- `GetWithValidation<T>(IValidator<T> validator, uint ind = 0)` - Get by index with validation
+- `GetWithValidation<T>(Func<T, bool> predicate, IValidator<T> validator)` - Get by predicate with validation
+- `GetWithValidationAsync<T>(int ind, IValidator<T> validator)` - Async get by index with validation
+- `GetAllWithValidationAsync<T>(IValidator<T> validator)` - Get all items with validation
+
+### Collection Methods (with validation when retrieving)
+- `GetAsListWithValidation<T>(IValidator<T> validator)` - Get as List with validation
+- `GetAsListWithValidation<T>(uint size, IValidator<T> validator)` - Get as List with size and validation
+- `GetAsEnumerableWithValidation<T>(IValidator<T> validator)` - Get as IEnumerable with validation
+- `GetAsSpanWithValidation<T>(IValidator<T> validator)` - Get as Span with validation
+- `GetAsReadonlySpanWithValidation<T>(IValidator<T> validator)` - Get as ReadOnlySpan with validation
+
+### Pure Validation Methods (validation without posting/retrieving)
+- `Validate<T>(T input, IValidator<T> validator)` - Synchronous validation only
+- `ValidateAsync<T>(T input, IValidator<T> validator)` - Asynchronous validation only
+
+### Utility Methods
+- `CreateWithValidation<T>(uint size, IValidator<T> validator)` - Create collection with validation support
 
 ## Usage
 
@@ -39,6 +68,19 @@ Snapshot.Out.PostWithValidation(product, validator);
 await Snapshot.Out.PostWithValidationAsync(product, validator);
 ```
 
+### Validation on Retrieval
+
+```csharp
+// Get object with validation
+var validatedProduct = Snapshot.Out.GetWithValidation(validator, 0);
+
+// Get collection with validation  
+var validatedList = Snapshot.Out.GetAsListWithValidation(validator);
+
+// Get all items with validation
+var validatedItems = await Snapshot.Out.GetAllWithValidationAsync(validator);
+```
+
 ### Validation Without Posting
 
 ```csharp