WPF Track child collection validation errors

Question

I have a need to get notified about validation errors that occur in a child collection of my ViewModel. For validation I use the INotifyDataErrorInfo interface.
I've created a class that handles this successfully however, I feel that additional refactoring / simplification can be done on it.
Here's the class that implements validation and child collection validation tracking:

public class Validatable : Observable, INotifyDataErrorInfo
{
    [XmlIgnore]
    private Dictionary<string, List<string>> errors =
            new Dictionary<string, List<string>>();

    [XmlIgnore]
    // a collection that keeps all child tracked collections
    public List<ICollection> TrackedCollections { get; set; } = new List<ICollection>();

    [XmlIgnore]
    public bool HasCollectionErrors { get; set; }

    // method used by the view model
    internal void RegisterCollection<T>(ObservableCollection<T> collection)
    {
        TrackedCollections.Add(collection);
        collection.CollectionChanged += Collection_CollectionChanged;
    }

    // handle tracked collections changed events and registeres / unregisteres the error changed events
    private void Collection_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
    {
        if (e.NewItems != null)
        {
            foreach (var item in e.NewItems.OfType<Validatable>())
            {
                item.ErrorsChanged += Item_ErrorsChanged;
            }
        }
        if (e.OldItems != null)
        {
            foreach (var item in e.OldItems.OfType<Validatable>())
            {
                item.ErrorsChanged -= Item_ErrorsChanged;
            }
        }
    }

    // notify parent about validation status change
    private void Item_ErrorsChanged(object sender, DataErrorsChangedEventArgs e)
    {
        HasCollectionErrors = false;
        foreach (var TrackedCollection in TrackedCollections)
        {
            foreach (var obj in TrackedCollection.OfType<Validatable>())
            {
                if (obj.HasErrors)
                {
                    HasCollectionErrors = true;
                    break;
                }
            }
        }
        OnPropertyChanged(nameof(IsValid));
    }

    public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;

    public bool IsValid => !HasErrors && !HasCollectionErrors;
    public bool HasErrors => errors.Any();

    public void OnErrorsChanged(string propertyName)
    {
        ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(propertyName));
    }

    public IEnumerable GetErrors(string propertyName)
    {
        if (string.IsNullOrWhiteSpace(propertyName)) return null;
        if (errors.ContainsKey(propertyName) &&
            errors[propertyName] != null &&
            errors[propertyName].Count > 0)
        {
            return errors[propertyName];
        }
        return null;
    }

    public void Validate()
    {
        ClearErrors();

        var results = new List<ValidationResult>();
        var context = new ValidationContext(this);
        Validator.TryValidateObject(this, context, results, true);

        if (results.Any())
        {
            var propertyNames = results.SelectMany(m => m.MemberNames).Distinct().ToList();

            foreach (var propertyName in propertyNames)
            {
                errors[propertyName] = results
                   .Where(m => m.MemberNames.Contains(propertyName))
                   .Select(r => r.ErrorMessage)
                   .Distinct()
                   .ToList();
                OnErrorsChanged(propertyName);
            }
        }
        OnPropertyChanged(nameof(IsValid));
    }

    protected void ClearErrors()
    {
        foreach (var propertyName in errors.Keys.ToList())
        {
            errors.Remove(propertyName);
            OnErrorsChanged(propertyName);
        }
    }
}

Observable class:

public class Observable : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        var handler = PropertyChanged;
        if (handler != null)
        {
            handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    protected virtual void SetProperty<T>(ref T member, T val, [CallerMemberName]string propertyName = null)
    {
        if (Equals(member, val)) return;

        member = val;
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

Sample View Model:

public class Person : Validatable
{
    private string _name;

    public Person()
    {
        Addresses = new ObservableCollection<Address>();
        RegisterCollection(Addresses);
    }

    [Required]
    public string Name
    {
        get { return _name; }
        set
        {
            SetProperty(ref _name, value);
            Validate();
        }
    }

    public ObservableCollection<Address> Addresses { get; private set; }
}

public class Address : Validatable
{
    private string _street;

    [Required]
    public string Street
    {
        get { return _street; }
        set
        {
            SetProperty(ref _street, value);
            Validate();
        }
    }
}

Answer 1

Validatable

In the Item_ErrorsChanged() method you have a naming issue in the foreach (var TrackedCollection in TrackedCollections) loop.

Local variables should be named using camelCase casing. TrackedCollection -> trackedCollection but maybe a different name would be better to distinguish it more from TrackedCollections.

This

protected void ClearErrors()
{
    foreach (var propertyName in errors.Keys.ToList())
    {
        errors.Remove(propertyName);
        OnErrorsChanged(propertyName);
    }
}  

is a little bit bloated

• Clearing all of the keys and values of a dictionary should be done using the Clear() method of the Dictionary<TKey, TValue>
• The call to ToList() on the KeyCollection is superflous

protected void ClearErrors()
{
    foreach (var propertyName in errors.Keys)
    {
        OnErrorsChanged(propertyName);
    }
    errors.Clear();
}  

Observable

You have some code duplication here. Why don't you call OnPropertyChanged() out of the SetProperty<T>() method ?

Your coding style gets inconsistent here. In the Validatable class you used the C# 6 feature using the null conditional operator ? and in this class you are checking against null.

You should change this class like so

public class Observable : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    protected virtual void SetProperty<T>(ref T member, T val, [CallerMemberName]string propertyName = null)
    {
        if (Equals(member, val)) { return; }

        member = val;

        OnPropertyChanged(propertyName);
    }
}  

As you can see I have added braces {} to the if of the SetProperty() method as well. I am a defender of always use them.