С# WPF OnPropertyChange не работает при использовании ValidationRules

Используйте свойство ValidationStep. Пример:

<local:StandardValidationRule ValidationStep = "UpdatedValue"
                              ValidatesOnTargetUpdated = "True"/>

Но для проверки исходного свойства нужна более сложная логика, так как валидатор получает не значение свойства, а выражение привязки от целевого свойства.

    public class StandardValidationRule : ValidationRule
    {
        private bool gettingValue = false;
        private bool isValueReceived = false;
        public override ValidationResult Validate(object value, CultureInfo cultureInfo)
        {
            if (gettingValue)
            {
                isValueReceived = true;
                return ValidationResult.ValidResult;
            }

            string? valueToValidate = value as string;

            ValidationResult? result = null;
            if (valueToValidate is null && value is not null)
            {
                if (value is BindingExpressionBase bindingExpression)
                {
                    gettingValue = true;
                    isValueReceived = false;
                    DependencyObject target = bindingExpression.Target;
                    var gettingValueExpression = BindingOperations.SetBinding(target, SourceValueProperty, bindingExpression.ParentBindingBase);
                    if (!isValueReceived)
                    {
                        gettingValueExpression.UpdateTarget();
                    }
                    valueToValidate = target.GetValue(SourceValueProperty)?.ToString();
                    target.ClearValue(SourceValueProperty);
                    gettingValue = false;
                }
                else
                {
                    result = unvalid;
                }
            }

            if (result is null)
            {
                result = string.IsNullOrEmpty(valueToValidate)
                            ? unvalid
                            : ValidationResult.ValidResult;
            }
            return result;
        }
        private static readonly ValidationResult unvalid = new ValidationResult(false, "Field is mandatory.");



        // Using a DependencyProperty as the backing store for SourceValue.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty SourceValueProperty =
            DependencyProperty.RegisterAttached("SourceValue", typeof(object), typeof(StandardValidationRule), new PropertyMetadata(null));


    }

Есть еще один способ получить исходное значение.
Он основан на использовании метода internal через отражение.
Что многие считают «плохим» способом.
Но работает гораздо эффективнее.
И я думаю вряд ли кто-то будет вносить изменения в метод internal, который уже во многих местах используется.

    public static class BindingExpressionHelper
    {
        private static readonly Func<BindingExpressionBase, DependencyObject, DependencyProperty, object> GetValueOfBindingExpression;

        static BindingExpressionHelper()
        {
            Type beType = typeof(BindingExpressionBase);
            var beMethod = beType
                .GetMethod("GetValue", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, new Type[] { typeof(DependencyObject), typeof(DependencyProperty) })
                ?? throw new Exception("GetValue method not found.");
            var beFunc = (Func<BindingExpressionBase, DependencyObject, DependencyProperty, object>)
                beMethod.CreateDelegate(typeof(Func<BindingExpressionBase, DependencyObject, DependencyProperty, object>));
            GetValueOfBindingExpression = beFunc;
        }

        /// <summary>Returns the source value of this binding expression.</summary>
        /// <param name = "bindingExpression">The binding expression whose value to get.</param>
        /// <returns>The value of the binding expression received.</returns>
        public static object? GetSourceValue(this BindingExpressionBase bindingExpression)
        {
            DependencyObject target = bindingExpression.Target;
            DependencyProperty targetProperty = bindingExpression.TargetProperty;
            var value = GetValueOfBindingExpression(bindingExpression, target, targetProperty);

            return value;
        }
    }

    public class StandardValidationRule : ValidationRule
    {
        public override ValidationResult Validate(object value, CultureInfo cultureInfo)
        {
            string? valueToValidate = value as string;

            ValidationResult? result = null;
            if (valueToValidate is null && value is not null)
            {
                if (value is BindingExpressionBase bindingExpression)
                {
                    valueToValidate = bindingExpression.GetSourceValue()?.ToString();
                }
                else
                {
                    result = unvalid;
                }
            }

            if (result is null)
            {
                result = string.IsNullOrEmpty(valueToValidate)
                            ? unvalid
                            : ValidationResult.ValidResult;
            }
            return result;
        }
        private static readonly ValidationResult unvalid = new ValidationResult(false, "Field is mandatory.");
    }