Please implement INotifyDataErrorInfo on Screen/PropertyChangedBase (3.0?)

This framework supports many platforms, so it would be great if it would also support the INotifyDataErrorInfo interface to offer custom validation through an async interface which wpf can bind to.

I am willing to contribute if you would consider this to be an option and are open for contributions.

I’ll show what i’ve done so far. It works but apart from the _errorsChanged handler having a strong referenced handler right now

I think a built in solution would be great to have

public class ValidationModelBase : PropertyChangedBase, INotifyDataErrorInfo
{
    private Dictionary<string, List<ValidationResult>> _errors = new Dictionary<string, List<ValidationResult>>();

    bool INotifyDataErrorInfo.HasErrors => _errors.Keys.Any();

    [field:NonSerialized]
    private EventHandler<DataErrorsChangedEventArgs> _errorsChanged;

    event EventHandler<DataErrorsChangedEventArgs> INotifyDataErrorInfo.ErrorsChanged
    {
        add { _errorsChanged += value; }
        remove { _errorsChanged -= value; }
    }

    protected void RaiseErrorsChanged(string propertyName)
    {
        _errorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
    }

    IEnumerable INotifyDataErrorInfo.GetErrors(string propertyName)
    {
        if (!_errors.ContainsKey(propertyName))
            yield break;

        foreach (var result in _errors[propertyName])
        {
            yield return result;
        }
    }

    private Dictionary<string, CancellationTokenSource> _validateCts = new Dictionary<string, CancellationTokenSource>();

    public bool SetValue<T>(ref T backingField, T value, string propertyName)
    {
        if (object.Equals(backingField, value))
            return false;

        backingField = value;

        var validationDelay = GetValidationDelay(propertyName);
        if (validationDelay > 0)
        {
            CancellationTokenSource source;
            if (_validateCts.TryGetValue(propertyName, out source))
            {
                source.Cancel();
                source = new CancellationTokenSource();
                _validateCts[propertyName] = source;
            }
            else
            {
                source = new CancellationTokenSource();
                _validateCts.Add(propertyName, source);
            }

            Task.Delay(validationDelay, source.Token).ContinueWith(d =>
            {
                ValidateProperty(value, propertyName);
                NotifyOfPropertyChange(propertyName);
            }, source.Token);
        }
        else
        {
            Task.Run(() =>
            {
                ValidateProperty(value, propertyName);
                NotifyOfPropertyChange(propertyName);
            });
        }

        return true;
    }

    private void ValidateProperty<T>(T value, string propertyName)
    {
        var validationResults = ValidationHelper.ValidateProperty(this, value, propertyName);
        OnValidateProperty<T>(value, propertyName, validationResults);
        if (validationResults.Count > 0)
        {
            AddErrors(propertyName, validationResults);
            RaiseErrorsChanged(propertyName);
        }
        else
        {
            ClearErrors(propertyName);
        }
    }

    protected virtual void OnValidateProperty<T>(T value, string propertyName, List<ValidationResult> validationResults)
    {
    }

    protected void AddErrors(string propertyName, List<ValidationResult> validationResults)
    {
        if (_errors.ContainsKey(propertyName))
        {
            _errors[propertyName] = validationResults;
        }
        else
        {
            _errors.Add(propertyName, validationResults);
        }
    }

    protected void ClearErrors(string propertyName)
    {
        _errors.Remove(propertyName);
    }

    protected virtual int GetValidationDelay(string propertyName)
    {
        var pi = this.GetType().GetProperty(propertyName);
        if (pi != null)
        {
            var delayAttr = pi.GetCustomAttribute<ValidationDelayAttribute>();
            if (delayAttr != null)
                return delayAttr.Delay;
        }

        return 0;
    }
}

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
public class ValidationDelayAttribute : Attribute
{
    public ValidationDelayAttribute(int delay)
    {
        Delay = delay;
    }

    /// <summary>
    /// Delay in milliseconds
    /// </summary>
    public int Delay { get; }
}

[taori]

ok i’ve browsed through the code of ConventionManager.cs and i guess i can see now how to provide a plugin based on that. I’m busy with other things right now but i’d probably work on it on the weekend and nudge you to have a look if i did it as you would have imagined this to be done (If that’s ok with you.) ?

[nigel-sampson]

No worries.