minlength - maxlength c# mvc

MaxLength Attribute no genera atributos de validación del lado del cliente

Question

Tengo un problema curioso con la validación del lado del cliente ASP.NET MVC3. Tengo la siguiente clase:

public class Instrument : BaseObject
{
    public int Id { get; set; }

    [Required(ErrorMessage = "Name is required.")]
    [MaxLength(40, ErrorMessage = "Name cannot be longer than 40 characters.")]
    public string Name { get; set; }
}

Desde mi vista:

<div class="editor-field">
    @Html.EditorFor(model => model.Name)
    @Html.ValidationMessageFor(model => model.Name)
</div>

Y aquí está el HTML generado que recibo para el cuadro de texto de este campo:

<input class="text-box single-line" data-val="true" data-val-required="Name is required." id="Name" name="Name" type="text" value="">

No hay señal de MaxLengthAttribute , pero todo lo demás parece estar funcionando.

Alguna idea de lo que va mal?

Answer 1

Acabo de usar un fragmento de jquery para resolver este problema.

$("input[data-val-length-max]").each(function (index, element) {
   var length = parseInt($(this).attr("data-val-length-max"));
   $(this).prop("maxlength", length);
});

El selector encuentra todos los elementos que tienen un conjunto de atributos data-val-length-max. Este es el atributo que establecerá el atributo de validación StringLength.

Cada bucle recorre estas coincidencias y analizará el valor de este atributo y lo asignará a la propiedad mxlength que debería haberse establecido.

Simplemente agréguele esto a la función de documento listo y listo.

Answer 2

Apoyos a @ Nick-Harrison por su respuesta:

$("input[data-val-length-max]").each(function (index, element) {
var length = parseInt($(this).attr("data-val-length-max"));
$(this).prop("maxlength", length);
});

Me preguntaba qué es el parseInt () para allí. Lo simplifiqué a esto sin problemas ...

$("input[data-val-length-max]").each(function (index, element) {
    element.setAttribute("maxlength", element.getAttribute("data-val-length-max"))
});

Hubiera comentado la respuesta de Nicks pero todavía no tengo suficientes representantes.

Answer 3

En MVC 4 Si quieres maxlenght en el tipo de entrada de texto? Usted puede !

@Html.TextBoxFor(model => model.Item3.ADR_ZIP, new { @class = "gui-input ui-oblig", @maxlength = "5" })

Answer 4

Esto puede reemplazar el MaxLength y el MinLength

[StringLength(40, MinimumLength = 10 , ErrorMessage = "Name cannot be longer than 40 characters and less than 10")]

Answer 5

Intenté esto para todas las entradas en mi documento html (textarea, entradas, etc.) que tenían la propiedad data-val-length-max y funciona correctamente.

$(document).ready(function () {
    $(":input[data-val-length-max]").each(function (index, element) {
        var length = parseInt($(this).attr("data-val-length-max"));
        $(this).prop("maxlength", length);
    });
});

Answer 6

Intente usar el atributo [StringLength] :

[Required(ErrorMessage = "Name is required.")]
[StringLength(40, ErrorMessage = "Name cannot be longer than 40 characters.")]
public string Name { get; set; }

Eso es para fines de validación. Si desea establecer, por ejemplo, el atributo maxlength en la entrada, puede escribir un proveedor de metadatos de anotaciones de datos personalizado como se muestra en esta publicación y personalizar las plantillas predeterminadas .

Answer 7

Sé que llegué muy tarde a la fiesta, pero finalmente descubrí cómo podemos registrar MaxLengthAttribute .

Primero necesitamos un validador:

public class MaxLengthClientValidator : DataAnnotationsModelValidator<MaxLengthAttribute>
{
    private readonly string _errorMessage;
    private readonly int _length;


    public MaxLengthClientValidator(ModelMetadata metadata, ControllerContext context, MaxLengthAttribute attribute)
    : base(metadata, context, attribute)
    {
        _errorMessage = attribute.FormatErrorMessage(metadata.DisplayName);
        _length = attribute.Length;
    }

    public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
    {
        var rule = new ModelClientValidationRule
        {
            ErrorMessage = _errorMessage,
            ValidationType = "length"
        };

        rule.ValidationParameters["max"] = _length;
        yield return rule;
    }
}

Nada realmente especial. En el constructor guardamos algunos valores del atributo. En GetClientValidationRules , establecemos una regla. ValidationType = "length" está correlacionado con data-val-length por el framework. rule.ValidationParameters["max"] es para el atributo data-val-length-max .

Ahora que tiene un validador, solo necesita registrarlo en global.asax :

protected void Application_Start()
{
    //...

    //Register Validator
    DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(MaxLengthAttribute), typeof(MaxLengthClientValidator));
}

Et voila, simplemente funciona.

Answer 8

Tuve el mismo problema y pude resolverlo implementando la interfaz IValidatableObject en mi modelo de vista.

public class RegisterViewModel : IValidatableObject
{
    /// <summary>
    /// Error message for Minimum password
    /// </summary>
    public static string PasswordLengthErrorMessage => $"The password must be at least {PasswordMinimumLength} characters";

    /// <summary>
    /// Minimum acceptable password length
    /// </summary>
    public const int PasswordMinimumLength = 8;

    /// <summary>
    /// Gets or sets the password provided by the user.
    /// </summary>
    [Required]
    [DataType(DataType.Password)]
    [Display(Name = "Password")]
    public string Password { get; set; }

    /// <summary>
    /// Only need to validate the minimum length
    /// </summary>
    /// <param name="validationContext">ValidationContext, ignored</param>
    /// <returns>List of validation errors</returns>
    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
    {
        var errorList = new List<ValidationResult>();
        if ((Password?.Length ?? 0 ) < PasswordMinimumLength)
        {
            errorList.Add(new ValidationResult(PasswordLengthErrorMessage, new List<string>() {"Password"}));
        }
        return errorList;
    }
}

El marcado en la Navaja es entonces ...

<div class="form-group">
    @Html.LabelFor(m => m.Password)
    @Html.PasswordFor(m => m.Password, new { @class = "form-control input-lg" }
    <div class="password-helper">Must contain: 8 characters, 1 upper-case, 1 lower-case
    </div>
    @Html.ValidationMessagesFor(m => m.Password, new { @class = "text-danger" })
</div>

Esto funciona realmente bien. Si intento usar [StringLength] en su lugar, entonces el HTML renderizado simplemente no es correcto. La validación debería representar como:

<span class="text-danger field-validation-invalid field-validation-error" data-valmsg-for="Password" data-valmsg-replace="true"><span id="Password-error" class="">The Password should be a minimum of 8 characters long.</span></span>

Con StringLengthAttribute, el HTML renderizado se muestra como un ValidationSummary que no es correcto. ¡Lo curioso es que cuando el validador falla, el envío sigue bloqueado!

Answer 9

MaxLengthAttribute funciona desde la actualización de MVC 5.1: cambiar notas

Answer 10

StringLength funciona muy bien, lo usé de esta manera:

[StringLength(25,MinimumLength=1,ErrorMessage="Sorry only 25 characters allowed for 
              ProductName")]
public string ProductName { get; set; }

o simplemente use RegularExpression sin StringLength:

[RegularExpression(@"^[a-zA-Z0-9''@&#./s]{1,25}$", ErrorMessage = "Reg Says Sorry only 25 
                   characters allowed for ProductName")]    
public string ProductName { get; set; }

pero para mí los métodos anteriores dieron error en la vista de visualización, porque ya tenía el campo ProductName en la base de datos que tenía más de 25 caracteres

así que finalmente me encontré con this y this publicación e intenté validar sin un modelo como este :

 <div class="editor-field">
 @Html.TextBoxFor(model => model.ProductName, new
 {
 @class = "form-control",
 data_val = "true",
 data_val_length = "Sorry only 25 characters allowed for ProductName",
 data_val_length_max = "25",
 data_val_length_min = "1"
 })
 <span class="validation"> @Html.ValidationMessageFor(model => model.ProductName)</span>
 </div>

esto solucionó mi problema, también puedes hacer la validación manualmente usando jquery o usando ModelState.AddModelError

la esperanza ayuda a alguien