MVC3中的選擇性驗證

Question

我有一個像這樣的地址類：

public class CustomerAddress
{
    [Required]
    public string Line1 { get; set; }

    public string Line2 { get; set; }

    [Required]
    public string Town { get; set; }

    [Required]
    public string Postcode { get; set; }
}

我有一個像這樣的視圖模型：

public class CheckoutViewModel
{
    [Required]
    public string Name { get; set; }

    //... etc

    public bool DeliverySameAsBilling { get; set; }

    public CustomerAddress BillingAddress { get; set; }

    public CustomerAddress DeliveryAddress { get; set; }
 }

我只希望送貨地址驗證時DeliverySameAsBilling是假的，我可以從看到這是IValidatableObject可能是要走的路。

與屬性相比，該示例在模型上施加了更嚴格的標准。 就我而言，我想選擇忽略CustomerAddress類中的[Required]屬性。 我該怎么做呢？ 我將如何連接適當的客戶端驗證？

我也可以像使用自定義屬性這在每個BillingAddress和DeliveryAddress ，然后也許是客戶端驗證會更容易處理; 但是，如果DeliverySameAsBilling為true，我仍然不知道如何有效地“取消”該屬性的驗證。

哪個最好？

Answer 1

看看這個。

http://blogs.msdn.com/b/simonince/archive/2010/06/04/conditional-validation-in-mvc.aspx

創建一個RequiredIfAttribute

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ComponentModel.DataAnnotations;

namespace ConditionalValidation.Validation
{
    public class RequiredIfAttribute : ValidationAttribute
    {
        // Note: we don't inherit from RequiredAttribute as some elements of the MVC
        // framework specifically look for it and choose not to add a RequiredValidator
        // for non-nullable fields if one is found. This would be invalid if we inherited
        // from it as obviously our RequiredIf only applies if a condition is satisfied.
        // Therefore we're using a private instance of one just so we can reuse the IsValid
        // logic, and don't need to rewrite it.
        private RequiredAttribute innerAttribute = new RequiredAttribute();
        public string DependentProperty { get; set; }
        public object TargetValue { get; set; }

        public RequiredIfAttribute(string dependentProperty, object targetValue)
        {
            this.DependentProperty = dependentProperty;
            this.TargetValue = targetValue;
        }

        public override bool IsValid(object value)
        {
            return innerAttribute.IsValid(value);
        }
    }
}

然后創建一個RequiredIfValidator

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace ConditionalValidation.Validation
{
    public class RequiredIfValidator : DataAnnotationsModelValidator<RequiredIfAttribute>
    {
        public RequiredIfValidator(ModelMetadata metadata, ControllerContext context, RequiredIfAttribute attribute)
            : base(metadata, context, attribute)
        {
        }

        public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            // no client validation - I might well blog about this soon!
            return base.GetClientValidationRules();
        }

        public override IEnumerable<ModelValidationResult> Validate(object container)
        {
            // get a reference to the property this validation depends upon
            var field = Metadata.ContainerType.GetProperty(Attribute.DependentProperty);

            if (field != null)
            {
                // get the value of the dependent property
                var value = field.GetValue(container, null);

                // compare the value against the target value
                if ((value == null && Attribute.TargetValue == null) ||
                    (value.Equals(Attribute.TargetValue)))
                {
                    // match => means we should try validating this field
                    if (!Attribute.IsValid(Metadata.Model))
                        // validation failed - return an error
                        yield return new ModelValidationResult { Message = ErrorMessage };
                }
            }
        }
    }
}

並在模型中使用它

namespace ConditionalValidation.Models
{
    public class Person
    {
        [HiddenInput(DisplayValue = false)]
        public int Id { get; set; }

        [StringLength(10)]
        [RequiredIf("City", null)]
        public string Name { get; set; }

        [RequiredIf("IsUKResident", true, ErrorMessage = "You must specify the City if UK resident")]
        public string City { get; set; }

        [RequiredIf("IsUKResident", false, ErrorMessage = "You must specify the country if not UK resident")]
        [RegularExpression("^(\\w)+$", ErrorMessage = "Only letters are permitted in the Country field")]
        public string Country { get; set; }

        // this field is last in the class - therefore any RequiredAttribute validation that occurs
        // on fields before it don't guarantee this field's value is correctly set - see my blog post 
        // if that doesn't make sense!
        [DisplayName("UK Resident")]
        public bool IsUKResident { get; set; }
    }
}