Validación condicional de ASP.NET MVC

¿Cómo usar anotaciones de datos para hacer una validación condicional en el modelo?

Por ejemplo, supongamos que tenemos el siguiente modelo (Persona y Senior):

public class Person
{
    [Required(ErrorMessage = "*")]
    public string Name
    {
        get;
        set;
    }

    public bool IsSenior
    {
        get;
        set;
    }

    public Senior Senior
    {
        get;
        set;
    }
}

public class Senior
{
    [Required(ErrorMessage = "*")]//this should be conditional validation, based on the "IsSenior" value
    public string Description
    {
        get;
        set;
    }
}

Y la siguiente vista:

<%= Html.EditorFor(m => m.Name)%>
<%= Html.ValidationMessageFor(m => m.Name)%>

<%= Html.CheckBoxFor(m => m.IsSenior)%>
<%= Html.ValidationMessageFor(m => m.IsSenior)%>

<%= Html.CheckBoxFor(m => m.Senior.Description)%>
<%= Html.ValidationMessageFor(m => m.Senior.Description)%>

Me gustaría ser el campo obligatorio condicional de propiedad "Senior.Description" basado en la selección de la propiedad "IsSenior" (verdadero -> obligatorio). ¿Cómo implementar la validación condicional en ASP.NET MVC 2 con anotaciones de datos?

Hay una forma mucho mejor de agregar reglas de validación condicional en MVC3; haga que su modelo herede IValidatableObjecte implemente el Validatemétodo:

public class Person : IValidatableObject
{
    public string Name { get; set; }
    public bool IsSenior { get; set; }
    public Senior Senior { get; set; }

    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext) 
    { 
        if (IsSenior && string.IsNullOrEmpty(Senior.Description)) 
            yield return new ValidationResult("Description must be supplied.");
    }
}

Lea más en Introducción a ASP.NET MVC 3 (Vista previa 1) .

He resuelto esto manejando el diccionario "ModelState" , que está contenido en el controlador. El diccionario ModelState incluye todos los miembros que deben validarse.

Aquí está la solución:

Si necesita implementar una validación condicional basada en algún campo (por ejemplo, si A = verdadero, entonces se requiere B), mientras se mantiene la mensajería de error a nivel de propiedad (esto no es cierto para los validadores personalizados que están a nivel de objeto) puede lograr esto manejando "ModelState", simplemente quitando validaciones no deseadas de él.

... en alguna clase ...

public bool PropertyThatRequiredAnotherFieldToBeFilled
{
  get;
  set;
}

[Required(ErrorMessage = "*")] 
public string DepentedProperty
{
  get;
  set;
}

... la clase continúa ...

... En alguna acción del controlador ...

if (!PropertyThatRequiredAnotherFieldToBeFilled)
{
   this.ModelState.Remove("DepentedProperty");
}

...

Con esto logramos la validación condicional, dejando todo lo demás igual.

ACTUALIZAR:

Esta es mi implementación final: he usado una interfaz en el modelo y el atributo de acción que valida el modelo que implementa dicha interfaz. La interfaz prescribe el método Validate (ModelStateDictionary modelState). El atributo en acción solo llama a Validate (modelState) en IValidatorSomething.

No quería complicar esta respuesta, por lo que no mencioné los detalles finales de implementación (que, al final, importan en el código de producción).

Tuve el mismo problema ayer, pero lo hice de una manera muy limpia que funciona tanto para la validación del lado del cliente como del lado del servidor.

Condición: según el valor de otra propiedad en el modelo, desea que se requiera otra propiedad. Aqui esta el codigo

public class RequiredIfAttribute : RequiredAttribute
{
    private String PropertyName { get; set; }
    private Object DesiredValue { get; set; }

    public RequiredIfAttribute(String propertyName, Object desiredvalue)
    {
        PropertyName = propertyName;
        DesiredValue = desiredvalue;
    }

    protected override ValidationResult IsValid(object value, ValidationContext context)
    {
        Object instance = context.ObjectInstance;
        Type type = instance.GetType();
        Object proprtyvalue = type.GetProperty(PropertyName).GetValue(instance, null);
        if (proprtyvalue.ToString() == DesiredValue.ToString())
        {
            ValidationResult result = base.IsValid(value, context);
            return result;
        }
        return ValidationResult.Success;
    }
}

Aquí PropertyName es la propiedad en la que desea establecer su condición. DesiredValue es el valor particular del PropertyName (propiedad) para el cual se debe validar su otra propiedad

Digamos que tienes lo siguiente

public class User
{
    public UserType UserType { get; set; }

    [RequiredIf("UserType", UserType.Admin, ErrorMessageResourceName = "PasswordRequired", ErrorMessageResourceType = typeof(ResourceString))]
    public string Password
    {
        get;
        set;
    }
}

Por último, pero no menos importante, registre el adaptador para su atributo para que pueda hacer la validación del lado del cliente (lo puse en global.asax, Application_Start)

 DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredIfAttribute),typeof(RequiredAttributeAdapter));

He estado usando este Nuget increíble que hace anotaciones dinámicas ExpressiveAnnotations

Podrías validar cualquier lógica con la que puedas soñar:

public string Email { get; set; }
public string Phone { get; set; }
[RequiredIf("Email != null")]
[RequiredIf("Phone != null")]
[AssertThat("AgreeToContact == true")]
public bool? AgreeToContact { get; set; }

Puede deshabilitar los validadores condicionalmente eliminando errores de ModelState:

ModelState["DependentProperty"].Errors.Clear();

Gracias Merritt :)

Acabo de actualizar esto a MVC 3 en caso de que alguien lo encuentre útil: Validación condicional en ASP.NET MVC 3 .

Ahora hay un marco que realiza esta validación condicional (entre otras validaciones de anotación de datos útiles) fuera de la caja: http://foolproof.codeplex.com/

Específicamente, eche un vistazo al validador [RequiredIfTrue ("IsSenior")]. Lo coloca directamente en la propiedad que desea validar, de modo que obtiene el comportamiento deseado del error de validación asociado a la propiedad "Senior".

Está disponible como un paquete NuGet.

Debe validar a nivel de Persona, no a nivel de Senior, o Senior debe tener una referencia a su Persona principal. Me parece que necesita un mecanismo de autovalidación que defina la validación en la Persona y no en una de sus propiedades. No estoy seguro, pero no creo que DataAnnotations lo admita de forma inmediata. Lo que puedes hacer crea el tuyo propio Attributeque ValidationAttributese puede decorar a nivel de clase y luego crear un validador personalizado que también permita que se ejecuten esos validadores a nivel de clase.

Sé que Validation Application Block admite la autovalidación fuera de la caja, pero VAB tiene una curva de aprendizaje bastante empinada. Sin embargo, aquí hay un ejemplo usando VAB:

[HasSelfValidation]
public class Person
{
    public string Name { get; set; }
    public bool IsSenior { get; set; }
    public Senior Senior { get; set; }

    [SelfValidation]
    public void ValidateRange(ValidationResults results)
    {
        if (this.IsSenior && this.Senior != null && 
            string.IsNullOrEmpty(this.Senior.Description))
        {
            results.AddResult(new ValidationResult(
                "A senior description is required", 
                this, "", "", null));
        }
    }
}

Tuve el mismo problema, necesitaba una modificación del atributo [Obligatorio]: hacer que el campo sea obligatorio en función de la solicitud http. La solución fue similar a la respuesta de Dan Hunex, pero su solución no funcionó correctamente (ver comentarios). No uso validación discreta, solo MicrosoftMvcValidation.js fuera de la caja. Aquí está. Implemente su atributo personalizado:

public class RequiredIfAttribute : RequiredAttribute
{

    public RequiredIfAttribute(/*You can put here pararmeters if You need, as seen in other answers of this topic*/)
    {

    }

    protected override ValidationResult IsValid(object value, ValidationContext context)
    {

    //You can put your logic here   

        return ValidationResult.Success;//I don't need its server-side so it always valid on server but you can do what you need
    }


}

Luego debe implementar su proveedor personalizado para usarlo como un adaptador en su global.asax

public class RequreIfValidator : DataAnnotationsModelValidator <RequiredIfAttribute>
{

    ControllerContext ccontext;
    public RequreIfValidator(ModelMetadata metadata, ControllerContext context, RequiredIfAttribute attribute)
       : base(metadata, context, attribute)
    {
        ccontext = context;// I need only http request
    }

//override it for custom client-side validation 
     public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
     {       
               //here you can customize it as you want
         ModelClientValidationRule rule = new ModelClientValidationRule()
         {
             ErrorMessage = ErrorMessage,
    //and here is what i need on client side - if you want to make field required on client side just make ValidationType "required"    
             ValidationType =(ccontext.HttpContext.Request["extOperation"] == "2") ? "required" : "none";
         };
         return new ModelClientValidationRule[] { rule };
      }
}

Y modifique su global.asax con una línea

DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredIfAttribute), typeof(RequreIfValidator));

Y aquí está

[RequiredIf]
public string NomenclatureId { get; set; }

La principal ventaja para mí es que no tengo que codificar un validador de cliente personalizado como en el caso de una validación discreta. funciona igual que [Obligatorio], pero solo en los casos que desee.

Echa un vistazo a la validación condicional de Simon Ince en MVC .

Estoy trabajando en su proyecto de ejemplo en este momento.

Uso típico para la eliminación condicional del error del estado del modelo:

1. Hacer la primera parte condicional de la acción del controlador
2. Realizar la lógica para eliminar el error de ModelState
3. Haga el resto de la lógica existente (normalmente validación del estado del modelo, luego todo lo demás)

Ejemplo:

public ActionResult MyAction(MyViewModel vm)
{
    // perform conditional test
    // if true, then remove from ModelState (e.g. ModelState.Remove("MyKey")

    // Do typical model state validation, inside following if:
    //     if (!ModelState.IsValid)

    // Do rest of logic (e.g. fetching, saving

En su ejemplo, mantenga todo como está y agregue la lógica sugerida a la Acción de su Controlador. Supongo que su ViewModel pasado a la acción del controlador tiene los objetos Person y Senior Person con datos completados en ellos desde la IU.

Estoy usando MVC 5 pero podrías probar algo como esto:

public DateTime JobStart { get; set; }

[AssertThat("StartDate >= JobStart", ErrorMessage = "Time Manager may not begin before job start date")]
[DisplayName("Start Date")]
[Required]
public DateTime? StartDate { get; set; }

En su caso, diría algo como "IsSenior == true". Entonces solo necesita verificar la validación en su acción de publicación.