Integracja Fluent Validation z WPF wersja async

MainWindow.xaml

<TextBox 
      Text="{Binding Email, 
              UpdateSourceTrigger=PropertyChanged, 
              Mode=TwoWay, 
              ValidatesOnNotifyDataErrors=True}"
      Name="Email"/>

MainWindowViewModel1.cs

public override Task<ValidationResult> SelfValidate()
{
     return Validator.ValidateAsync(this);
}

MainWindowViewModelValidator.cs

public class MainWindowViewModelValidator : AbstractValidator<MainWindowViewModel>
{
    public MainWindowViewModelValidator()
    {
        RuleFor(u => u.Email)
            .Cascade(CascadeMode.StopOnFirstFailure)
            .NotEmpty()
            .EmailAddress()
            .MustAsync((email, token) => ValidateEmail(email, token))
            .WithMessage("Email must be unique");
            
    }

    private async Task<bool> ValidateEmail(string email, CancellationToken token)
    {
        await Task.Delay(2000);

        return email != "daniel@plawgo.pl";
    }
}

ViewModel1.cs

public virtual Task<ValidationResult> SelfValidate() 
{
      return Task.FromResult(new ValidationResult());
}

ViewModel2.cs

private bool _isValidating;
public bool IsValidating
{
     get { return _isValidating; }
     set
     {
          if (_isValidating != value)
          {
               _isValidating = value;
               OnPropertyChanged(() => this.IsValidating);
          }
     }
}

private ValidationResult ValidationResult { get; set; }

ViewModel3.cs

public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

private void OnErrorsChanged(string propertyName)
{
    if (ErrorsChanged == null)
    {
        return;
    }

    ErrorsChanged(this, new DataErrorsChangedEventArgs(propertyName));
}

public bool HasErrors => IsValid == false;

public IEnumerable GetErrors(string propertyName)
{
    if (ValidationResult == null)
    {
        return new List<string>();
    }

    return ValidationResult.Errors.Where(e => e.PropertyName == propertyName).Select(e => e.ErrorMessage).ToList();
}

ViewModel4.cs

protected async Task<bool> Validate()
{
    IsValidating = true;

    ValidationResult = await SelfValidate();

    IsValidating = false;

    IsValid = ValidationResult.IsValid;

    if (IsValid == false)
    {
        foreach(var propertyName in ValidationResult.Errors.Select(e => e.PropertyName).Distinct())
        {
            OnErrorsChanged(propertyName);
        }
    }               

    return IsValid;
}

ViewModel5.cs

private async void OnPropertyChanged(string propertyName)
{
    var propertyChanged = PropertyChanged;

    if (propertyChanged == null)
    {
        return;
    }

    propertyChanged(this, new PropertyChangedEventArgs(propertyName));

    if (propertyName != nameof(IsValid) && propertyName != nameof(IsValidating))
    {
        await Validate();

        if(ValidationResult.Errors.Any(e => e.PropertyName == propertyName) == false)
        {
            OnErrorsChanged(propertyName);
        }
    }
}