The built in annotation-based validation in MVC is fine, but sometimes you need to validate a property relative to other properties on the page.  For example, you might want to make sure that two properties are the same (password and confirm password) for example.

This post explains how to extend the validation model to cater for this.

First we need to create new validation attributes to annotate our data model with.  I use the following interface for all attributes that require more than one field to validate:

/// summary>
/// All validation data annotation attributes that require more than one
/// property to validate (or additional context) should implement this
/// interface.
// </summary>
public interface IRichValidationAttribute
{
    /// <summary>
    /// Determines whether the specified property is valid.
    /// </summary>
    /// <param name="controllerContext">Complete controller context (if required).</param>
    /// <param name="model">The model object to which the property belongs.</param>
    /// <param name="modelMetadata">Model metadata relating to the property holding
    /// the validation data annotation.</param>
    /// <returns>
    /// <c>true</c> if the specified property is valid; otherwise, <c>false</c>.
    /// </returns>
    bool IsValid(ControllerContext controllerContext, object model, ModelMetadata modelMetadata);
}

Now we can create a new attribute that implements this interface:

[AttributeUsage(AttributeTargets.Property |   AttributeTargets.Field, AllowMultiple = false)]
public class NotEqualToPropertyAttribute : ValidationAttribute, IRichValidationAttribute
{
   /// <summary>
    /// Gets or sets the other property we are validating against.
    /// </summary>
    public string OtherProperty { get; set; }

   /// <summary>
    /// Determines whether the specified value of the object is valid.
    /// </summary>
    /// <param name="value">
    /// The value of the specified validation object on which the attribute is declared.
    /// </param>
    /// <returns>
    /// true if the specified value is valid; otherwise, false.
    /// </returns>
    public override bool IsValid(object value)
    {
        // Work done in other IsValid
        return true;
    }

    /// <summary>
    /// Determines whether the specified property is valid.
    /// </summary>
    /// <param name="controller">Complete controller context (if required).</param>
    /// <param name="model">The model object to which the property belongs.</param>
     /// <param name="modelMetadata">Model metadata relating to the property holding the validation data annotation. </param>
     /// <returns>
     /// true if the specified property is valid; otherwise, false.
     /// </returns>
     public bool IsValid(ControllerContext controllerContext, object model, ModelMetadata modelMetadata)
     {
        if (model == null)
        {
             throw new ArgumentNullException("model");
        }
        // Find the value of the other property.
        var propertyInfo = model.GetType().GetProperty(OtherProperty);
        if (propertyInfo == null)
        {
           throw new InvalidOperationException(string.Format("Couldn't find {0} property on {1}.", OtherProperty, model));
        }
        var otherValue = propertyInfo.GetGetMethod().Invoke(model, null);
        return modelMetadata.Model.ToString() != otherValue.ToString();
    }
}

This can then be applied to the model:

[NotEqualToProperty(ErrorMessage = "Other occupation cannot be the same as the main occupation",
OtherProperty = "Occupation")]
public Occupation OtherOccupation { get; set; }

Now we need to create a validator for the attribute. I’ve created a base class for all validators than used the enhanced validation interface:

/// <summary>
/// A base class for validators that have attributes that require more
/// than one property to check for validity.
/// The standard <see cref="ValidationAttribute.IsValid"/> method
/// isn't sufficient because this method can't see the rest of the model.
/// </summary>
/// <typeparam name="TAttribute">The type of the attribute.</typeparam>
public abstract class CrossFieldValidator<TAttribute> : DataAnnotationsModelValidator<TAttribute> where TAttribute : ValidationAttribute
{
    protected CrossFieldValidator(ModelMetadata metadata, ControllerContext context, TAttribute attribute) : base(metadata, context, attribute)
    {
    }
}

/// <summary>
/// Returns a list of validation error messages for the model.
/// </summary>
/// <param name="container">The container for the model.</param>
/// <returns>
/// A list of validation error messages for the model, or an empty list if no errors have occurred.
/// </returns>
public override IEnumerable<ModelValidationResult> Validate(object container)
{
var attribute = Attribute as IRichValidationAttribute;
if (attribute != null)
{
if (!attribute.IsValid(ControllerContext, container, Metadata))
{
yield return new ModelValidationResult { Message = ErrorMessage };
}
}
else if (!Attribute.IsValid(container))
{
yield return new ModelValidationResult { Message = ErrorMessage };
}
}

Finally we need to create the client-side script:

jQuery.validator.addMethod("notequaltoproperty", function(value, element, params) {
    if (this.optional(element)) {
        return true;
    }

   var otherPropertyControl = $("#" + params.otherProperty);
    if (otherPropertyControl == null) {
       return false;
    }

    var otherPropertyValue = otherPropertyControl[0].value;
    return otherPropertyValue != value;
});

And that’s it.