Ressource par défaut pour les annotations de données dans ASP.NET MVC

Question

Existe-t-il un moyen de définir la ressource par défaut pour les validations d'annotations de données ?

Je ne veux pas faire quelque chose comme ça :

[Required(ErrorMessage="Name required.", ErrorMessageResourceType=typeof(CustomDataAnnotationsResources)]
public string Name { get; set; }

Je voudrais quelque chose comme ceci :

Global.asax

DataAnnotations.DefaultResources = typeof(CustomDataAnnotationsResources);

alors

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

que quelqu'un m'éclaire !

Merci d'avance

MODIFIER

Mon vrai problème était avec EF Code First CTP4.CTP5 corrige le problème.Merci pour tout le monde.

Answer 1

Vous pouvez essayer de faire ceci:

Ajoutez cette classe quelque part dans votre projet:

 public class ExternalResourceDataAnnotationsValidator : DataAnnotationsModelValidator<ValidationAttribute>
{
    /// <summary>
    /// The type of the resource which holds the error messqages
    /// </summary>
    public static Type ResourceType { get; set; }

    /// <summary>
    /// Function to get the ErrorMessageResourceName from the Attribute
    /// </summary>
    public static Func<ValidationAttribute, string> ResourceNameFunc 
    {
        get { return _resourceNameFunc; }
        set { _resourceNameFunc = value; }
    }
    private static Func<ValidationAttribute, string> _resourceNameFunc = attr => attr.GetType().Name;

    public ExternalResourceDataAnnotationsValidator(ModelMetadata metadata, ControllerContext context, ValidationAttribute attribute)
        : base(metadata, context, attribute)
    {
        if (Attribute.ErrorMessageResourceType == null)
        {
            this.Attribute.ErrorMessageResourceType = ResourceType;
        }

        if (Attribute.ErrorMessageResourceName == null)
        {
            this.Attribute.ErrorMessageResourceName = ResourceNameFunc(this.Attribute);
        }
    }
}

et dans votre global.aSax, ajoutez ce qui suit:

// Add once
ExternalResourceDataAnnotationsValidator.ResourceType = typeof(CustomDataAnnotationsResources);

// Add one line for every attribute you want their ErrorMessageResourceType replaced.
DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RangeAttribute), typeof(ExternalResourceDataAnnotationsValidator));

Il recherchera une propriété avec le même nom que le type de validateur pour le message d'erreur.Vous pouvez changer cela via la propriété Resourcenamefunc.

EDIT: AFAIK Ceci fonctionne à partir de MVC2 en avant, car DataannotationsModelvalidatorProvider a été introduit dans MVC2.

Answer 2

Pour y parvenir, j'ai créé une nouvelle classe qui hérite d'ObligatoireAttribute, et le message d'erreur est intégré à l'intérieur de cette nouvelle classe:

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

Le message d'erreur est extrait du fichier validationResource.resx, où je répertorie le message d'erreur comme suit:

Compteyterormessage -> "{0} est requis."

où {0}= nom d'affichage.

J'ai ensuite annoté mes modèles comme celui-ci, je n'ai donc jamais besoin de répéter mes déclarations de message d'erreur:

[RequiredWithMessage]
public string Name { get; set; }

Une fois que vous faites cela, un message d'erreur ("nom est requis.") apparaîtra chaque fois que la validation échoue.

Ceci fonctionne correctement avec la validation du côté serveur ASP.NET MVC et la validation côté client.

Answer 3

J'ai fait une autre approche.Il faut encore que tu hérites DataAnnotation attributs, mais vous pouvez obtenir une solution de traduction plus flexible.

Coder de mon article de blog (lisez-le pour plus de détails)

Résultat final

public class User
{
    [Required]
    [LocalizedDisplayNameAttribute("User_Id")]
    public int Id { get; set; }

    [Required]
    [StringLength(40)]
    [LocalizedDisplayNameAttribute("User_FirstName")]
    public string FirstName { get; set; }

    [Required]
    [StringLength(40)]
    [LocalizedDisplayNameAttribute("User_LastName")]
    public string LastName { get; set; }
}

1 Hériter de tous les attributs d'annotation de données comme celui-ci

public class RequiredAttribute : System.ComponentModel.DataAnnotations.RequiredAttribute
{
    private string _displayName;

    public RequiredAttribute()
    {
        ErrorMessageResourceName = "Validation_Required";
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        _displayName = validationContext.DisplayName;
        return base.IsValid(value, validationContext);
    }

    public override string FormatErrorMessage(string name)
    {
        var msg = LanguageService.Instance.Translate(ErrorMessageResourceName);
        return string.Format(msg, _displayName);
    }
}

2 Hériter de DisplayNameAttribute

public class LocalizedDisplayNameAttribute : DisplayNameAttribute
{
    private PropertyInfo _nameProperty;
    private Type _resourceType;

    public LocalizedDisplayNameAttribute(string className, string propertyName)
        : base(className + (propertyName == null ? "_Class" : ("_" + propertyName)))
    {

    }

    public override string DisplayName
    {
        get
        {
            return LanguageService.Instance.Translate(base.DisplayName) ?? "**" + base.DisplayName + "**";
        }
    }
}

3.Créez le service linguistique (vous pouvez y basculer vers n'importe quelle source linguistique)

public class LanguageService
{
    private static LanguageService _instance = new LanguageService();
    private List<ResourceManager> _resourceManagers = new List<ResourceManager>();

    private LanguageService()
    {
    }

    public static LanguageService Instance { get { return _instance; } }

    public void Add(ResourceManager mgr)
    {
        _resourceManagers.Add(mgr);
    }

    public string Translate(string key)
    {
        foreach (var item in _resourceManagers)
        {
            var value = item.GetString(key);
            if (value != null)
                return value;
        }

        return null;
    }
}

Enfin, vous devez enregistrer les tables de chaînes que vous utilisez pour traduire les messages de validation et vos modèles

LanguageService.Instance.Add(MyNameSpace.ModelResource.ResourceManager);
LanguageService.Instance.Add(MyNameSpace.ValidationResources.ResourceManager);