MVC: Reemplace el ValidationMessage predeterminado

Question

En el mundo de MVC tengo este modelo de vista ...

public class MyViewModel{

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

... y este tipo de cosas en mi opinión ...

<%= Html.ValidationSummary("Please correct the errors and try again.") %>
<%= Html.TextBox("FirstName") %>
<%= Html.ValidationMessage("FirstName", "*") %>

Mi pregunta: si envío este formulario sin proporcionar un nombre, aparece el siguiente mensaje " El campo Nombre es obligatorio "

OK. Entonces, voy y cambio mi propiedad a ...

[DisplayName("First Name")]
[Required]
public string FirstName{ get; set; }    

... y ahora obtenga " El campo Nombre es obligatorio "

Todo bien hasta ahora.

Así que ahora quiero que aparezca el mensaje de error " Nombre Blah Blah " ;. ¿Cómo puedo anular el mensaje predeterminado para mostrar DisplayName + " Blah Blah " ;, sin anotar todas las propiedades con algo como

[Required(ErrorMessage = "First Name Blah Blah")]

Saludos,

ETFairfax

Answer 1

public class GenericRequired: RequiredAttribute
{
    public GenericRequired()
    {
        this.ErrorMessage = "{0} Blah blah"; 
    }
}

Answer 2

Aquí hay una manera de hacerlo sin subclasificar RequiredAttribute . Solo haz algunas clases de adaptadores de atributos. Aquí estoy usando ErrorMessageResourceType / ErrorMessageResourceName (con un recurso) pero puede configurar fácilmente ErrorMessage , o incluso verificar la existencia de anulaciones antes configurando estos.

Global.asax.cs:

public class MvcApplication : HttpApplication {
    protected void Application_Start() {
        // other stuff here ...
        DataAnnotationsModelValidatorProvider.RegisterAdapter(
            typeof(RequiredAttribute), typeof(CustomRequiredAttributeAdapter));
        DataAnnotationsModelValidatorProvider.RegisterAdapter(
            typeof(StringLengthAttribute), typeof(CustomStringLengthAttributeAdapter));
    }
}

private class CustomRequiredAttributeAdapter : RequiredAttributeAdapter {
    public CustomRequiredAttributeAdapter(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute)
        : base(metadata, context, attribute)
    {
        attribute.ErrorMessageResourceType = typeof(Resources);
        attribute.ErrorMessageResourceName = "ValRequired";
    }
}

private class CustomStringLengthAttributeAdapter : StringLengthAttributeAdapter {
    public CustomStringLengthAttributeAdapter(ModelMetadata metadata, ControllerContext context, StringLengthAttribute attribute)
        : base(metadata, context, attribute)
    {
        attribute.ErrorMessageResourceType = typeof(Resources);
        attribute.ErrorMessageResourceName = "ValStringLength";
    }
}

Este ejemplo le permitiría crear un archivo de recursos llamado Resources.resx con ValRequired como el nuevo mensaje predeterminado requerido y ValStringLength ya que la longitud de la cadena superó el mensaje predeterminado. Tenga en cuenta que para ambos, {0} recibe el nombre del campo, que puede configurar con [Mostrar (Nombre = " Nombre de campo ")] .

Answer 3

Parece que RequiredAttribute no implementa IClientValidatable, por lo que si reemplaza el RequiredAttribute, se rompe la validación del lado del cliente.

Así que esto es lo que hice y funciona. Espero que esto ayude a alguien.

public class CustomRequiredAttribute : RequiredAttribute, IClientValidatable
{
    public CustomRequiredAttribute()
    {
        this.ErrorMessage = "whatever your error message is";
    }

    public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
    {
        yield return new ModelClientValidationRule
        {
            ErrorMessage = this.ErrorMessage,
            ValidationType = "required"
        };
    }
}

Answer 4

Sólo cambia

[Required] 

a

[Required(ErrorMessage = "Your Message, Bla bla bla aaa!")]

Answer 5

Editar: publiqué esto porque estaba buscando esta solución con el atributo [Requerido] y tuve problemas para encontrarla. Crear un nuevo Q / A no se ve tan bien, ya que esta pregunta ya existe.

Estaba intentando resolver lo mismo y encontré una solución muy simple en MVC 4.

Primero, probablemente tendrías que almacenar mensajes de error en algún lugar. Usé recursos personalizados, bien descritos en http://afana.me/post/aspnet-mvc -internationalization.aspx .

Importante es que puedo obtener cualquier recurso (incluso un mensaje de error) simplemente llamando a ResourcesProject.Resources.SomeCustomError o ResourcesProject.Resources.MainPageTitle etc. Siempre que lo intento para acceder a la clase de Recursos, toma información de la cultura del hilo actual y devuelve el idioma correcto.

Tengo un mensaje de error para la validación de campo en ResourcesProject.Resources.RequiredAttribute . Para configurar este mensaje para que aparezca en Vista, simplemente actualice el atributo [Requerido] con estos dos parámetros.

ErrorMessageResourceType : tipo al que se llamará (en nuestro ejemplo ResourcesProject.Resources)

ErrorMessageResourceName - Propiedad, que se llamará en el tipo anterior (en nuestro caso RequiredAttribute)

Aquí hay un modelo de inicio de sesión muy simplificado, que muestra solo el mensaje de validación del nombre de usuario. Cuando el campo esté vacío, tomará la cadena de ResourcesProject.Resources.RequiredAttribute y la mostrará como un error.

    public class LoginModel
    {        
        [Required(ErrorMessageResourceType = typeof(Resources.Resources), ErrorMessageResourceName="RequiredAttribute")]
        [Display(Name = "User name")]
        public string UserName { get; set; }
}

Answer 6

Puedes escribir tu propio atributo:

public class MyRequiredAttribute : ValidationAttribute
{
    MyRequiredAttribute() : base(() => "{0} blah blah blah blaaaaaah")
    {

    }

    public override bool IsValid(object value)
    {
        if (value == null)
        {
            return false;
        }
        string str = value as string;
        if (str != null)
        {
            return (str.Trim().Length != 0);
        }
        return true;
    }
}

Esta es una copia de RequiredAttribute from Reflector con un mensaje de error modificado.

Answer 7

using Resources;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Web;
using System.Web.Mvc;

public class CustomRequiredAttribute : RequiredAttribute,  IClientValidatable
{
    public CustomRequiredAttribute()
    {
        ErrorMessageResourceType = typeof(ValidationResource);
        ErrorMessageResourceName = "RequiredErrorMessage";
    }


    public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
    {


        yield return new ModelClientValidationRule
        {
            ErrorMessage = GetRequiredMessage(metadata.DisplayName),
            ValidationType = "required"
        };
    }


    private string GetRequiredMessage(string displayName) {

        return displayName + " " + Resources.ValidationResource.RequiredErrorMessageClient;        

    }


}

App_GlobalResources / ValidationResource.resx

Ahora usa anotación de datos

[CustomRequired]

Answer 8

Esto funcionó para mí. Lea atentamente los comentarios dentro del código. (Basado en la respuesta de Chad).

 // Keep the name the same as the original, it helps trigger the original javascript 
 // function for client side validation.

        public class RequiredAttribute : System.ComponentModel.DataAnnotations.RequiredAttribute, IClientValidatable
            {
                public RequiredAttribute()
                {
                    this.ErrorMessage = "Message" // doesnt get called again. only once.
                }

                public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
                {
                    yield return new ModelClientValidationRule
                    {
                        ErrorMessage = "Message", // this gets called on every request, so it's contents can be dynamic.
                        ValidationType = "required"
                    };
                }
            }