Tengo una clase Student que contiene la lista de propiedades 'TextPair' como se muestra a continuación:

public class Student
{
    public List<TextPair> Hobbies { get; set; }
    public List<TextPair> Languages { get; set; }
    public List<TextPair> Majors { get; set; }

}

public class TextPair
{
    [StringLength(2, ErrorMessage = "The value length is invalid")]
    public string Value { get; set; }

    public string Text { get; set; }
}

Aquí, valido el valor para la longitud máxima 2 usando StringLength AttributeValidator y lo decoro en la propiedad 'Valor' dentro del modelo TextPair. El problema para mí es que la longitud siempre es fija y la longitud siempre es obligatoria.

En mi caso de uso, quiero que el sabor diferente de Value en diferentes partes de la aplicación (o propiedades diferentes del mismo tipo) admita diferentes longitudes.

Estaba buscando algo como a continuación donde pudiera pasar la validación en mi clase donde declaro mi propiedad 'TextPair' [es decir, No quiero que la validación sea obligatoria siempre y tampoco codificar el valor 2]

public class Student
{
    //Any length of the value is accepted for hobbies
    public List<TextPair> Hobbies{ get; set; }

    [ValuesLength(Length = 2, ErrorMessage = "Language code length must be 2 characters max")]
    public List<TextPair> Languages { get; set; }

    [ValuesLength(Length = 128, ErrorMessage = "The major should be within 128 characters length")]
    public List<TextPair> Majors{ get; set; }

}

¿Existe alguna forma eficaz de abordar esta solución?

0
OmGanesh 21 feb. 2018 a las 05:18

2 respuestas

La mejor respuesta

Una de las soluciones abordadas es la siguiente:

public class Student
{
    //Any length of the value is accepted for hobbies
    public List<TextPair> Hobbies{ get; set; }

    [ValuesLength(MaximumLength = 2, ErrorMessage = "Language code length must be 2 characters max")]
    public List<TextPair> Languages { get; set; }

    [ValuesLength(MaximumLength = 128, ErrorMessage = "The major should be within 128 characters length")]
    public List<TextPair> Majors{ get; set; }

}

Mi validación de atributo personalizado es verificar la lista y verificar si alguno de los valores del elemento excede la longitud proporcionada como:

public class ValuesLengthAttribute : ValidationAttribute
    {
        public int MaximumLength { get; set; }
        public override Boolean IsValid(object value)
        {
            Boolean isValid = true;
            var list = value as List<TextPair>;
            if (list != null && list.Count>0)
                foreach (var item in list)
                {
                    if (item.Value.Length > MaximumLength)
                        isValid = false;
                }

            return isValid;
        }
    }
0
OmGanesh 21 feb. 2018 a las 19:23

Tal vez intente crear una subclasificación de StringLengthAttribute para crear el atributo ValuesLength que desee. Tenga en cuenta que este código no se ha probado y es solo una sugerencia para la implementación final.

public class ValuesLength : StringLengthAttribute
{
    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        var isValid = true;

        var pair = value as TextPair;
        if (pair != null && pair.Value != null)
        {
            var pairValue = pair.Value;
            isValid = pairValue.Length < MaximumLength && pairValue.Length > MinimumLength;
        }        

        return IsValid ? ValidationResult.Success : new ValidationResult(ErrorMessage);
    }
}
0
zhuber 21 feb. 2018 a las 09:21