Question

Here is what I have:

In the view there is a tab control with two tabs (sys1 and sys2) each with the same textboxes that are bound to the properties of their respective entities:

sys1:

<TextBox Text="{Binding sys1.Serial, ValidatesOnExceptions=True, NotifyOnValidationError=True}" />

sys2:

<TextBox Text="{Binding sys2.Serial, ValidatesOnExceptions=True, NotifyOnValidationError=True}" />

Using some form of validation I would like to compare the two values and display an error (red border is fine) if the values don’t match.

I’ve used IDataErrorInfo before, but I’m not sure if this type of validation is possible.

Note: whether or not binding directly to the entity is “correct” is a discussion for another place and time. Just know that this is a team project and our teams standards are to bind to the entity so I can’t change that unless I have a good reason. Perhaps if it’s not possible validating when bound directly to the entity then I may have a good enough reason to change this.

Thanks

Answer 1

I usually expose a Validation Delegate from my Model that my ViewModel can use to attach business-rule validation to the Models.

For example, the ViewModel containing your objects might look like this:

public ParentViewModel()
{
    sys1.AddValidationErrorDelegate(ValidateSerial);
    sys2.AddValidationErrorDelegate(ValidateSerial);
}

private string ValidateSerial(object sender, string propertyName)
{
    if (propertyName == "Serial")
    {
        if (sys1.Serial == sys2.Serial)
            return "Serial already assigned";
    }
    return null;
}

The idea is that your Model should only contain raw data, therefore it should only validate raw data. This can include validating things like maximum lengths, required fields, and allowed characters. Business Logic, which includes business rules, should be validated in the ViewModel and this allows that to happen.

The actual implementation of my IDataErrorInfo on the Model class would look like this:

#region IDataErrorInfo & Validation Members

/// <summary>
/// List of Property Names that should be validated
/// </summary>
protected List<string> ValidatedProperties = new List<string>();

#region Validation Delegate

public delegate string ValidationErrorDelegate(object sender, string propertyName);

private List<ValidationErrorDelegate> _validationDelegates = new List<ValidationErrorDelegate>();

public void AddValidationErrorDelegate(ValidationErrorDelegate func)
{
    _validationDelegates.Add(func);
}

#endregion // Validation Delegate

#region IDataErrorInfo for binding errors

string IDataErrorInfo.Error { get { return null; } }

string IDataErrorInfo.this[string propertyName]
{
    get { return this.GetValidationError(propertyName); }
}

public string GetValidationError(string propertyName)
{
    // If user specified properties to validate, check to see if this one exists in the list
    if (ValidatedProperties.IndexOf(propertyName) < 0)
    {
        //Debug.Fail("Unexpected property being validated on " + this.GetType().ToString() + ": " + propertyName);
        return null;
    }

    string s = null;

    // If user specified a Validation method to use, Validate property
    if (_validationDelegates.Count > 0)
    {
        foreach (ValidationErrorDelegate func in _validationDelegates)
        {
            s = func(this, propertyName);
            if (s != null)
            {
                return s;
            }
        }
    }

    return s;
}

#endregion // IDataErrorInfo for binding errors

#region IsValid Property

public bool IsValid
{
    get
    {
        return (GetValidationError() == null);
    }
}

public string GetValidationError()
{
    string error = null;

    if (ValidatedProperties != null)
    {
        foreach (string s in ValidatedProperties)
        {
            error = GetValidationError(s);
            if (error != null)
            {
                return error;
            }
        }
    }

    return error;
}

#endregion // IsValid Property

#endregion // IDataErrorInfo & Validation Members

P.S. I see nothing wrong with binding directly to the Model, especially in smaller applications. It may not be the “MVVM-purist” approach, however it is efficient and a lot less work, so I find it a perfectly valid option.