Convalida della vista generale con un datagrid e mantenimento in MVVM

Supponendo di avere una classe di prodotto, ogni prodotto non dovrebbe sapere altri prodotti nell'elenco.

Nella tua GUI, ti suggerisco di utilizzare ProductViewModel, responsabile della convalida di tutte le informazioni. Pertanto, non c'è alcun problema nel rendere ProductViewModel in possesso di altre istanze dello stesso tipo nella sua raccolta genitore. Una volta completata la convalida, è possibile generare una raccolta di Prodotti, se necessario.

Ecco alcuni codici che tentano di illustrare il mio suggerimento:

La tua classe di entità dei dati

public class Product {
    public int Id {get;set;}
    public string Name {get;set;}
}

Il tuo modello di visualizzazione (responsabile della convalida di tutto)

//Represents the view model for the Product.
//This view model is responsible for validating information of the product.
//As part of  this validation, it is necessary that this instance know
//details of the collection it belongs.
public class ProductViewModel : INotifyDataErrorInfo {

    //This could be injected via constructor or property.
    //Represents the collection of products, that requires validation
    //See its definition below
    private ProductViewModelCollection parentCollection;

    public int Id { 
        get { return _id; }
        set { if (ValidateId(value))) _id = value; }
    }
    public string Name {
        get { return _name; }
        set { if (ValidateName(value)) _name = value; }
    }

    //The methods below validate all info.
    //Alternatively, you could implement the validation somewhere else, 
    //and inject the necessary validators into this viewModel instance.
    private bool ValidateId(int id) { 
        //... validate the id...

        foreach (ProductViewModel otherProduct in parentCollection) {
            //...if necessary, perform additional validations comparing
            //with other products in the parent collection
        }
    }
    private bool ValidateName(string name) { 
        //... validate the name...

        foreach (ProductViewModel otherProduct in parentCollection) {
            //...if necessary, perform additional validations comparing
            //with other products in the parent collection
        }
    }

    //...implementation of INotifyDataErrorInfo...
}

La tua raccolta di prodotti, è la fonte per il datagrid

public class ProductViewModelCollection : ObservableCollection<ProductViewModel>, IINotifyDataErrorInfo {
    //...implementation of INotifyDataErrorInfo...
}

Dopo questo, non sarà necessario utilizzare la convalida incorporata dei componenti dell'interfaccia utente; puoi implementare tutto nel modello di visualizzazione, riuscendo a testare l'unità di conseguenza. La conoscenza attraverso la raccolta è implementata in ViewModel (perché la tua GUI lo richiede), non all'interno della tua entità di dati.

UPDATE: Secondo approccio (tramite iniezione):

//Represents the view model for the Product.
//This view model is responsible for validating information of the product.
//As part of  this validation, it is necessary that this instance know
//details of the collection it belongs.
public class ProductViewModel : INotifyDataErrorInfo {

    //Injected via constructor or property.
    private IProductValidator validator;

    //String properties, IF YOUR GUI ALLOWS user to type
    //text in the fields
    public string Id { 
        get { return _id; }
        set { if (validator.ValidateId(value))) _id = value; }
    }
    public string Name {
        get { return _name; }
        set { if (validator.ValidateName(value)) _name = value; }
    }

    public Product GetProduct() {
        //...generate Product object with valid info...
    }
}

public class ProductValidator : IProductValidator {

    //This could be injected via constructor or property.
    //Represents the collection of products, that requires validation
    //See its definition below
    private ProductViewModelCollection parentCollection;

    //The methods below validate all info.
    //Alternatively, you could implement the validation somewhere else, 
    //and inject the necessary validators into this viewModel instance.
    private bool ValidateId(string id) { 
        //... validate the id...

        foreach (ProductViewModel otherProduct in parentCollection) {
            //...if necessary, perform additional validations comparing
            //with other products in the parent collection
        }
    }
    private bool ValidateName(string name) { 
        //... validate the name...

        foreach (ProductViewModel otherProduct in parentCollection) {
            //...if necessary, perform additional validations comparing
            //with other products in the parent collection
        }
    }

    //...implementation of INotifyDataErrorInfo...
}

Se davvero devi implementare la modifica all'interno di una griglia, per eseguire la convalida sia l'elemento dati che il modello viewmodel principale devono implementare INotifyPropertyChanged, con IDataErrorInfo gestito dall'elemento dati.

Questa è la classe del modello di base che uso per gestire la convalida

public abstract class ValidatingModelBase : INotifyPropertyChanged, IDataErrorInfo
{
    private readonly Dictionary<string, List<ValidationRule>> _validationRules = new Dictionary<string, List<ValidationRule>>();

    #region INotifyPropertyChanged
    public event PropertyChangedEventHandler PropertyChanged;

    public virtual void RaisePropertyChanged(string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
    #endregion

    #region IDataErrorInfo
    public string this[string columnName]
    {
        get
        {
            var result = string.Empty;

            if (_validationRules.ContainsKey(columnName))
                foreach (var errorCheck in _validationRules[columnName])
                {
                    if (errorCheck.IsValid.Invoke())
                        continue;

                    result = errorCheck.FailErrorMessage;
                    break;
                }

            var errorStateChanged = string.IsNullOrWhiteSpace(result) 
                ? _invalidProperties.Remove(columnName) 
                : _invalidProperties.Add(columnName);

            if (errorStateChanged && !nameof(IsValid).Equals(columnName))
                RaisePropertyChanged(nameof(IsValid));

            return result;
        }
    }

    public string Error => string.Empty;
    #endregion

    private readonly HashSet<string> _invalidProperties = new HashSet<string>();

    public bool IsValid => !_invalidProperties.Any();

    public bool HasError(string propertyName) => _invalidProperties.Contains(propertyName);

    public void AddValidationRule(string propertyName, Func<bool> isValid, string failErrorMessage)
    {
        if (!_validationRules.ContainsKey(propertyName))
            _validationRules[propertyName] = new List<ValidationRule>();

        _validationRules[propertyName].Add(new ValidationRule(isValid, failErrorMessage));
    }

    // =============================================================================== 

    private class ValidationRule
    {
        public ValidationRule(Func<bool> isValid, string failErrorMessage)
        {
            IsValid = isValid;
            FailErrorMessage = failErrorMessage;
        }

        public Func<bool> IsValid { get; }
        public string FailErrorMessage { get; }
    }
}

quindi, data una classe modello

public PersonModel: ValidatingModelBase
{
    public PersonModel()
    {
        AddValidationRule(nameof(FirstName), !string.IsNullorWhiteSpace(FirstName), "First Name can't be blank");
        ...
    }

    private string _firstName;
    public string FirstName
    {
        get { return _firstName; }
        set {
                _firstName = value;   
                RaisePropertyChanged(nameof(FirstName));
            }
    }

    ....
}

nel tuo ViewModel potresti scrivere qualcosa come

public MainViewModel: INotifyPropertyChanged
{
    public MainViewModel()
    {
        GridData = _dataService.GetPeople();

        foreach(var person in PersonGridData)
            person.PropertyChanged += (s,e) => if (nameof(Person.IsValid).equals(e.PropertyName))
                                                   RaisePropertyChanged(nameof(PersonGridIsValid));
    }

    public ICollection<PersonModel> PersonGridData {get;}

    public bool PersonGridIsValid => PersonGridData.All(p => p.IsValid);
}

La proprietà PersonGridIsValid può quindi essere utilizzata per determinare se l'intera vista è in uno stato valido.