MVVM блокировка кнопки до валидации

        public PersonViewModel CreatePersonVM() => new PersonViewModel(model);

    public static partial class CommandHelper
    {
        private static RoutedUICommand _addPersonWindow;
        public static RoutedUICommand AddPersonWindow
        {
            get
            {
                if (_addPersonWindow is null)
                {
                    _addPersonWindow = new RoutedUICommand("Открыть окно добавления Person", nameof(AddPersonWindow), typeof(CommandHelper));
                    CommandManager.RegisterClassCommandBinding(typeof(Window), new CommandBinding(_addPersonWindow, OnAddPersonWindow, OnCanAddPersonWindow));
                }
                return _addPersonWindow;
            }
        }
 
        private static void OnCanAddPersonWindow(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = e.Source is FrameworkElement fe && fe.DataContext is MainWindowViewModel;
        }
 
        private static void OnAddPersonWindow(object sender, ExecutedRoutedEventArgs e)
        {
            if (!(e.Source is FrameworkElement fe && fe.DataContext is MainWindowViewModel vm))
                throw new NotImplementedException("Команда должна вызываться для контекста данных MainWindowViewModel");
 
            var wind = new AddPersonWindow()
            {
                DataContext = vm.CreatePersonVM(),
            };
            wind.Show();
        }
 
    }

    public partial class PersonViewModel : INotifyDataErrorInfo
    {
 
        public bool HasErrors =>
            string.IsNullOrWhiteSpace(Name) ||
            string.Equals(Name, "Вася", StringComparison.OrdinalIgnoreCase) ||
            !ValidateAge(DateOfBirth);
 
 
        public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;
        protected void RaiseErrorsChanged([CallerMemberName] string propertyName = null)
            => ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
 
        public IEnumerable GetErrors(string propertyName)
        {
            if (string.IsNullOrEmpty(propertyName))
            {
                foreach (var err in GetErrors(nameof(Name)))
                {
                    yield return $"{nameof(Name)}: {err}";
                }
                foreach (var err in GetErrors(nameof(DateOfBirth)))
                {
                    yield return $"{nameof(DateOfBirth)}: {err}";
                }
                yield break;
            }
 
            if (propertyName is nameof(Name))
            {
                if (string.IsNullOrWhiteSpace(Name))
                {
                    yield return "Name is required";
                }
 
                if (string.Equals(Name, "Вася", StringComparison.OrdinalIgnoreCase))
                {
                    yield return "Васям не положено!";
                }
            }
 
            else if (propertyName is nameof(DateOfBirth))
            {
                if (!ValidateAge(DateOfBirth))
                {
                    yield return "Must be 18 or older";
                }
            }
        }
    }

 public abstract class BaseViewModel : INotifyDataErrorInfo, IValidatable

    private Dictionary<string, HashSet<string>> _errors; // Сейчас так
    private readonly Dictionary<string, HashSet<string>> _errors = new(); // Надо так

public IEnumerable GetErrors(string propertyName)

        public IEnumerable GetErrors(string propertyName)
        {
            if (string.IsNullOrEmpty(propertyName))
            {
                foreach (KeyValuePair<string, HashSet<string>> prop in _errors)
                {
                    foreach (string error in prop.Value)
                    {
                        if (!string.IsNullOrWhiteSpace(error))
                            yield return $"{prop}: {error}";
                    }
                }
            }
 
            if (_errors.TryGetValue(propertyName, out HashSet<string> propertyErrors))
            {
                foreach (var error in propertyErrors)
                yield return error;
            }
        }

        public bool Validate<T>(T validateValue, [CallerMemberName] string propertyName = null)

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.CompilerServices;
 
namespace DTO_Validation.ViewModels
{
    public abstract class BaseViewModel : INotifyDataErrorInfo, IValidatable
    {
        #region INotifyDataErrorInfo
 
        private readonly Dictionary<string, HashSet<string>> _errors = new Dictionary<string, HashSet<string>>();
 
        public bool HasErrors => _errors.Count > 0;
 
        public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;
 
        public IEnumerable GetErrors(string propertyName)
        {
            if (string.IsNullOrEmpty(propertyName))
            {
                foreach (KeyValuePair<string, HashSet<string>> prop in _errors)
                {
                    foreach (string error in prop.Value)
                    {
                        if (!string.IsNullOrWhiteSpace(error))
                            yield return $"{prop}: {error}";
                    }
                }
            }
 
            if (_errors.TryGetValue(propertyName, out HashSet<string> propertyErrors))
            {
                foreach (var error in propertyErrors)
                    yield return error;
            }
        }
 
        protected void AddValidationError(string error, [CallerMemberName] string propertyName = "")
        {
            if (propertyName == null)
                propertyName = string.Empty;
 
            if (!_errors.ContainsKey(propertyName))
                _errors[propertyName] = new HashSet<string>();
 
            if (_errors[propertyName].Add(error))
                RaiseValidationErrorsChanged(propertyName);
 
            // После изменения состояний ошибок надо подымать INPC для HasErrors
        }
 
        protected void ClearValidationErrors([CallerMemberName] string propertyName = "")
        {
            if (propertyName == null)
                propertyName = string.Empty;
 
            if (string.IsNullOrEmpty(propertyName))
            {
                _errors.Clear();
            }
            else
            {
                if (_errors.Remove(propertyName))
                    RaiseValidationErrorsChanged(propertyName);
            }
            // После изменения состояний ошибок надо подымать INPC для HasErrors
        }
 
        protected void ClearAllValidationErrors()
        {
            RaiseValidationErrorsChanged(string.Empty);
        }
 
        private void RaiseValidationErrorsChanged(string propertyName)
        {
            RaiseErrorsChanged(new DataErrorsChangedEventArgs(propertyName));
        }
 
        protected virtual void RaiseErrorsChanged(DataErrorsChangedEventArgs e) => ErrorsChanged?.Invoke(this, e);
        #endregion
 
        #region IValidatable
        private readonly Dictionary<string, Func<object, ValidationRes>> _verificationMethods = new Dictionary<string, Func<object, ValidationRes>>();
 
        public void Register(string propertyName, Func<object, ValidationRes> validatingMetod)
        {
            if (propertyName == null)
                propertyName = string.Empty;
 
            if (validatingMetod is null)
            {
                _verificationMethods.Remove(propertyName);
            }
            else
            {
                _verificationMethods[propertyName] = validatingMetod;
            }
        }
 
        public bool Validate<T>(T validateValue, [CallerMemberName] string propertyName = null)
        {
            bool _isValid = true;
 
            if (propertyName == null)
                propertyName = string.Empty;
 
            ClearValidationErrors(propertyName);
 
            if (_verificationMethods.TryGetValue(propertyName, out Func<object, ValidationRes> validatingMetod))
            {
                ValidationRes result = validatingMetod(validateValue);
                if (!result.Success) // Ошибка валидации есть
                {
                    AddValidationError(result.ErrorMessage, propertyName);
                    _isValid = false;
                }
            }
 
            return _isValid;
        }
        #endregion
 
 
    }
}

    public PersonDTO Person { get; }

    public Action<PersonDTO> SaveChanges { get; set; }