.Net 6.0 version

[robertodalmonte]

Hi there,
for my own need, I refactored it to .Net 6.0 (like every other project in my solution).
Secondly, I wanted to strong sign the assembly as well. In case someone is interested here's the code.

<PropertyGroup>
	<TargetFramework>net6.0</TargetFramework>
	<ImplicitUsings>enable</ImplicitUsings>
	<Nullable>enable</Nullable>
	<LangVersion>10.0</LangVersion>
	<EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
	<AnalysisLevel>latest</AnalysisLevel>
	<AssemblyOriginatorKeyFile>MyStrongKey.snk</AssemblyOriginatorKeyFile>
	<SignAssembly>True</SignAssembly>
	<NeutralLanguage>en-US</NeutralLanguage>
</PropertyGroup>

<ItemGroup>
	<PackageReference Include="FluentValidation" Version="10.3.5" />
	<PackageReference Include="Microsoft.AspNetCore.Components" Version="6.0.0" />
	<PackageReference Include="Microsoft.AspNetCore.Components.Web" Version="6.0.0" />
	<PackageReference Include="IDisposableAnalyzers" Version="4.0.0">
		<PrivateAssets>all</PrivateAssets>
		<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
	</PackageReference>
</ItemGroup>

<ItemGroup>
	<SupportedPlatform Include="browser" />
</ItemGroup>

using FluentValidation;
using FluentValidation.Internal;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Forms;

namespace Blazored.FluentValidation;

public class ValidationValidator : ComponentBase
{
[Inject] private IServiceProvider? ServiceProvider { get; set; }

[CascadingParameter] private EditContext? CurrentEditContext { get; set; }

[Parameter] public IValidator? Validator { get; set; }
[Parameter] public bool DisableAssemblyScanning { get; set; }

internal Action<ValidationStrategy<object>>? Options;

public bool Validate(Action<ValidationStrategy<object>> options)
{
    Options = options;

    try
    {
        return CurrentEditContext?.Validate() == true;
    }
    finally
    {
        Options = null;
    }
}

protected override void OnInitialized()
{
    if (CurrentEditContext == null)
    {
        throw new InvalidOperationException($"{nameof(ValidationValidator)} requires a cascading " +
                                            $"parameter of type {nameof(EditContext)}. For example, you can use {nameof(ValidationValidator)} " +
                                            $"inside an {nameof(EditForm)}.");
    }

    CurrentEditContext.AddFluentValidation(ServiceProvider, DisableAssemblyScanning, Validator, this);
}

}

using FluentValidation;
using FluentValidation.Internal;
using Microsoft.AspNetCore.Components.Forms;
using Microsoft.Extensions.DependencyInjection;
using static FluentValidation.AssemblyScanner;

namespace Blazored.FluentValidation;

public static class EditContextFluentValidationExtensions
{
private static readonly char[] Separators = { '.', '[' };
private static readonly List<string?> ScannedAssembly = new();
private static readonly List AssemblyScanResults = new();

public static EditContext AddFluentValidation(this EditContext editContext, IServiceProvider? serviceProvider, bool disableAssemblyScanning, IValidator? validator, ValidationValidator validationValidator)

{
    if (editContext == null)
    {
        throw new ArgumentNullException(nameof(editContext));
    }

    var messages = new ValidationMessageStore(editContext);

    editContext.OnValidationRequested +=
        (sender, _) => ValidateModel((EditContext)sender!, messages, serviceProvider, disableAssemblyScanning, validationValidator, validator);

    editContext.OnFieldChanged +=
        (_, eventArgs) => ValidateField(editContext, messages, eventArgs.FieldIdentifier, serviceProvider, disableAssemblyScanning, validator);

    return editContext;
}

private static void ValidateModel(EditContext? editContext,
    ValidationMessageStore messages,
    IServiceProvider? serviceProvider,
    bool disableAssemblyScanning,
    ValidationValidator validationValidator,
    IValidator? validator = null)
{
    validator ??= GetValidatorForModel(serviceProvider, editContext?.Model, disableAssemblyScanning);

    if (validator is not null && editContext is not null)
    {
        var context = ValidationContext<object>.CreateWithOptions(editContext.Model, validationValidator.Options ?? (opt => opt.IncludeAllRuleSets()));

        var validationResults = validator.Validate(context);

        messages.Clear();
        foreach (var validationResult in validationResults.Errors)
        {
            var fieldIdentifier = ToFieldIdentifier(editContext, validationResult.PropertyName);
            messages.Add(fieldIdentifier, validationResult.ErrorMessage);
        }

        editContext.NotifyValidationStateChanged();
    }
}

private static void ValidateField(EditContext editContext,
    ValidationMessageStore messages,
    FieldIdentifier fieldIdentifier,
    IServiceProvider? serviceProvider,
    bool disableAssemblyScanning,
    IValidator? validator = null)
{
    var properties = new[] { fieldIdentifier.FieldName };
    var context = new ValidationContext<object>(editContext.Model, new PropertyChain(), new MemberNameValidatorSelector(properties));

    validator ??= GetValidatorForModel(serviceProvider, editContext.Model, disableAssemblyScanning);

    if (validator is not null)
    {
        var validationResults = validator.Validate(context);

        messages.Clear(fieldIdentifier);
        messages.Add(fieldIdentifier, validationResults.Errors.Select(error => error.ErrorMessage));

        editContext.NotifyValidationStateChanged();
    }
}

private static IValidator? GetValidatorForModel(IServiceProvider? serviceProvider, object? model, bool disableAssemblyScanning)
{
    if (model != null)
    {
        var validatorType = typeof(IValidator<>).MakeGenericType(model.GetType());
        if (serviceProvider is not null)
        {
            if (serviceProvider.GetService(validatorType) is IValidator validator)
            {
                return validator;
            }
        }
    }

    if (disableAssemblyScanning)
    {
        return null;
    }

    foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies().Where(i => !ScannedAssembly.Contains(i.FullName)))
    {
        AssemblyScanResults.AddRange(FindValidatorsInAssembly(assembly));
        ScannedAssembly.Add(assembly.FullName);
    }

    if (model != null)
    {
        var interfaceValidatorType = typeof(IValidator<>).MakeGenericType(model.GetType());

        var modelValidatorType = AssemblyScanResults.Find(i => interfaceValidatorType.IsAssignableFrom(i.InterfaceType))?.ValidatorType;

        if (modelValidatorType is null)
        {
            return null;
        }

        if (serviceProvider is not null)
        {
            return (IValidator)ActivatorUtilities.CreateInstance(serviceProvider, modelValidatorType);
        }
    }

    return null;
}

private static FieldIdentifier ToFieldIdentifier(in EditContext? editContext, in string propertyPath)
{
    // This code is taken from an article by Steve Sanderson (https://blog.stevensanderson.com/2019/09/04/blazor-fluentvalidation/)
    // all credit goes to him for this code.

    // This method parses property paths like 'SomeProp.MyCollection[123].ChildProp'
    // and returns a FieldIdentifier which is an (instance, propName) pair. For example,
    // it would return the pair (SomeProp.MyCollection[123], "ChildProp"). It traverses
    // as far into the propertyPath as it can go until it finds any null instance.

    if (editContext != null)
    {
        var obj = editContext.Model;
        var nextTokenEnd = propertyPath.IndexOfAny(Separators);

        // Optimize for a scenario when parsing isn't needed.
        if (nextTokenEnd < 0)
        {
            return new FieldIdentifier(obj, propertyPath);
        }

        ReadOnlySpan<char> propertyPathAsSpan = propertyPath;

        while (true)
        {
            var nextToken = propertyPathAsSpan[..nextTokenEnd];
            propertyPathAsSpan = propertyPathAsSpan[(nextTokenEnd + 1)..];

            object? newObj;
            if (nextToken.EndsWith("]"))
            {
                // It's an indexer
                // This code assumes C# conventions (one indexer named Item with one param)
                nextToken = nextToken[..^1];
                var prop = obj.GetType().GetProperty("Item");

                if (prop is not null)
                {
                    // we've got an Item property
                    var indexerType = prop.GetIndexParameters()[0].ParameterType;
                    var indexerValue = Convert.ChangeType(nextToken.ToString(), indexerType);
                    newObj = prop.GetValue(obj, new[] { indexerValue });
                }
                else
                {
                    // If there is no Item property
                    // Try to cast the object to array
                    if (obj is object[] array)
                    {
                        var indexerValue = int.Parse(nextToken);
                        newObj = array[indexerValue];
                    }
                    else
                    {
                        throw new InvalidOperationException($"Could not find indexer on object of type {obj.GetType().FullName}.");
                    }
                }
            }
            else
            {
                // It's a regular property
                var prop = obj.GetType().GetProperty(nextToken.ToString());
                if (prop == null)
                {
                    throw new InvalidOperationException($"Could not find property named {nextToken.ToString()} on object of type {obj.GetType().FullName}.");
                }
                newObj = prop.GetValue(obj);
            }

            if (newObj is null)
            {
                // This is as far as we can go
                return new FieldIdentifier(obj, nextToken.ToString());
            }

            obj = newObj;

            nextTokenEnd = propertyPathAsSpan.IndexOfAny(Separators);
            if (nextTokenEnd < 0)
            {
                return new FieldIdentifier(obj, propertyPathAsSpan.ToString());
            }
        }
    }

    throw new ArgumentNullException(nameof(editContext), $"{nameof(editContext)} is null");
}

/// <summary>
/// Runs an function that returns a value and ignores any Exceptions that occur.
/// Returns true or falls depending on whether catch was
/// triggered
/// </summary>
/// <param name="operation">parameterless lamda that returns a value of T</param>
/// <param name="defaultValue">Default value returned if operation fails</param>
public static T? IgnoreErrors<T>(Func<T>? operation, T? defaultValue = default)
{
    if (operation is null)
    {
        return defaultValue;
    }

    T? result;
    try
    {
        result = operation.Invoke();
    }
    catch
    {
        result = defaultValue;
    }

    return result;
}

}

Regards
Roberto Dalmonte