Anotaciones de datos para la validación, ¿al menos un campo obligatorio?

Question

Si tengo un objeto de búsqueda con una lista de campos, ¿puedo, mediante el espacio de nombres System.ComponentModel.DataAnnotaciones, configurarlo para validar que al menos uno de los campos en la búsqueda no es nulo o está vacío? Es decir, todos los campos son opcionales, pero al menos uno siempre debe ingresarse.

Answer 1

que crearía un validador personalizado para esto - que ganaron No le damos validación del lado del cliente, solo del lado del servidor.

Tenga en cuenta que para que esto funcione, usted necesita utilizar nullable tipos, como los tipos de valor por defecto se 0 o false:

En primer lugar crear un nuevo validador:

using System.ComponentModel.DataAnnotations; 
using System.Reflection; 

// This is a class-level attribute, doesn't make sense at the property level 
[AttributeUsage(AttributeTargets.Class)] 
public class AtLeastOnePropertyAttribute : ValidationAttribute 
{ 
    // Have to override IsValid 
    public override bool IsValid(object value) 
    { 
    // Need to use reflection to get properties of "value"... 
    var typeInfo = value.GetType(); 

    var propertyInfo = typeInfo.GetProperties(); 

    foreach (var property in propertyInfo) 
    { 
     if (null != property.GetValue(value, null)) 
     { 
     // We've found a property with a value 
     return true; 
     } 
    } 

    // All properties were null. 
    return false; 
    } 
} 

Puede luego decorar sus modelos con esto:

[AtLeastOneProperty(ErrorMessage="You must supply at least one value")] 
public class SimpleTest 
{ 
    public string StringProp { get; set; } 
    public int? Id { get; set; } 
    public bool? BoolProp { get; set; } 
} 

luego, cuando se llama a ModelState.IsValid su validador b e llamado, y su mensaje se agregará al ValidationSummary en su vista.

Tenga en cuenta que puede ampliar esto para verificar el tipo de propiedad que se devuelve, o buscar los atributos en ellos para incluir/excluir de la validación si así lo desea; esto es asumiendo un validador genérico que no sabe nada sobre el tipo que está validando

Answer 2

Si usted quiere hacer la validación compleja contra cualquier clase de .NET, sin LiteRing con anotaciones, mira FluentValidation, o para .Net 2.0, FluentValidation for 2.0

Answer 3

He extendido la respuesta de Zhaph para admitir la agrupación de propiedades.

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)] 
public class AtLeastOnePropertyAttribute : ValidationAttribute 
{ 
    private string[] PropertyList { get; set; } 

    public AtLeastOnePropertyAttribute(params string[] propertyList) 
    { 
     this.PropertyList = propertyList; 
    } 

    //See http://stackoverflow.com/a/1365669 
    public override object TypeId 
    { 
     get 
     { 
      return this; 
     } 
    } 

    public override bool IsValid(object value) 
    { 
     PropertyInfo propertyInfo; 
     foreach (string propertyName in PropertyList) 
     { 
      propertyInfo = value.GetType().GetProperty(propertyName); 

      if (propertyInfo != null && propertyInfo.GetValue(value, null) != null) 
      { 
       return true; 
      } 
     } 

     return false; 
    } 
} 

Uso:

[AtLeastOneProperty("StringProp", "Id", "BoolProp", ErrorMessage="You must supply at least one value")] 
public class SimpleTest 
{ 
    public string StringProp { get; set; } 
    public int? Id { get; set; } 
    public bool? BoolProp { get; set; } 
} 

Y si usted quiere tener 2 grupos (o más):

[AtLeastOneProperty("StringProp", "Id", ErrorMessage="You must supply at least one value")] 
[AtLeastOneProperty("BoolProp", "BoolPropNew", ErrorMessage="You must supply at least one value")] 
public class SimpleTest 
{ 
    public string StringProp { get; set; } 
    public int? Id { get; set; } 
    public bool? BoolProp { get; set; } 
    public bool? BoolPropNew { get; set; } 
} 

Answer 4

Esta pregunta es bastante viejo, pero a partir de .NET 3.5 (I creer), IValidatableObject puede ayudar con situaciones de validación difíciles. Puede implementarlo para validar reglas comerciales arbitrarias. En este caso, algo así como:

public IEnumerable<ValidationResult> Validate(ValidationContext validationContext) 
{ 
    if (string.IsNullOrWhiteSpace(FieldOne) && string.IsNullOrWhiteSpace(FieldTwo)) 
     yield return new ValidationResult("Must provide value for either FieldOne or FieldTwo.", new string[] { "FieldOne", "FieldTwo" }); 
}