Tengo una aplicación localizada y me pregunto si es posible DisplayNameestablecer la propiedad de un determinado modelo a partir de un Recurso.

Me gustaría hacer algo como esto:

public class MyModel {
  [Required]
  [DisplayName(Resources.Resources.labelForName)]
  public string name{ get; set; }
}

Pero no puedo hacerlo, como dice el compilador: "Un argumento de atributo debe ser una expresión constante, tipo de expresión o expresión de creación de matriz de un tipo de parámetro de atributo" :(

¿Hay alguna solución? Estoy enviando etiquetas manualmente, ¡pero las necesito para la salida del validador!

¿Qué tal escribir un atributo personalizado:

public class LocalizedDisplayNameAttribute: DisplayNameAttribute
{
    public LocalizedDisplayNameAttribute(string resourceId) 
        : base(GetMessageFromResource(resourceId))
    { }

    private static string GetMessageFromResource(string resourceId)
    {
        // TODO: Return the string from the resource file
    }
}

que podría usarse así:

public class MyModel 
{
    [Required]
    [LocalizedDisplayName("labelForName")]
    public string Name { get; set; }
}

Si usa MVC 3 y .NET 4, puede usar el nuevo Displayatributo en el System.ComponentModel.DataAnnotationsespacio de nombres. Este atributo reemplaza al DisplayNameatributo y proporciona mucha más funcionalidad, incluido el soporte de localización.

En su caso, lo usaría así:

public class MyModel
{
    [Required]
    [Display(Name = "labelForName", ResourceType = typeof(Resources.Resources))]
    public string name{ get; set; }
}

Como nota al margen, este atributo no funcionará con recursos dentro App_GlobalResourceso App_LocalResources. Esto tiene que ver con la herramienta personalizada ( GlobalResourceProxyGenerator) que utilizan estos recursos. En su lugar, asegúrese de que su archivo de recursos esté configurado en 'Recurso incorporado' y use la herramienta personalizada 'ResXFileCodeGenerator'.

(Como nota adicional, no deberías usar App_GlobalResourceso App_LocalResourcescon MVC. Puedes leer más sobre por qué este es el caso aquí )

Si abre su archivo de recursos y cambia el modificador de acceso a público o interno, generará una clase a partir de su archivo de recursos que le permitirá crear referencias de recursos fuertemente tipadas.

Lo que significa que puede hacer algo como esto (usando C # 6.0). Entonces no tienes que recordar si el primer nombre estaba en minúsculas o en camello. Y puede ver si otras propiedades usan el mismo valor de recurso con buscar todas las referencias.

[Display(Name = nameof(PropertyNames.FirstName), ResourceType = typeof(PropertyNames))]
public string FirstName { get; set; }

Actualizar:

Sé que es demasiado tarde, pero me gustaría agregar esta actualización:

Estoy usando el proveedor de metadatos de modelos convencionales que presentado por Phil Haacked es más potente y fácil de aplicar. Míralo : ConventionalModelMetadataProvider

Vieja respuesta

Aquí, si desea admitir muchos tipos de recursos:

public class LocalizedDisplayNameAttribute : DisplayNameAttribute
{
    private readonly PropertyInfo nameProperty;

    public LocalizedDisplayNameAttribute(string displayNameKey, Type resourceType = null)
        : base(displayNameKey)
    {
        if (resourceType != null)
        {
            nameProperty = resourceType.GetProperty(base.DisplayName,
                                           BindingFlags.Static | BindingFlags.Public);
        }
    }

    public override string DisplayName
    {
        get
        {
            if (nameProperty == null)
            {
                return base.DisplayName;
            }
            return (string)nameProperty.GetValue(nameProperty.DeclaringType, null);
        }
    }
}

Entonces úsalo así:

    [LocalizedDisplayName("Password", typeof(Res.Model.Shared.ModelProperties))]
    public string Password { get; set; }

Para ver el tutorial completo de localización, consulte esta página .

Obtuve la respuesta de Gunders al trabajar con mi App_GlobalResources eligiendo las propiedades de los recursos y cambié "Herramienta personalizada" a "PublicResXFileCodeGenerator" y creé la acción a "Recursos integrados". Observe el comentario de Gunders a continuación.

Funciona de maravilla :)

public class Person
{
    // Before C# 6.0
    [Display(Name = "Age", ResourceType = typeof(Testi18n.Resource))]
    public string Age { get; set; }

    // After C# 6.0
    // [Display(Name = nameof(Resource.Age), ResourceType = typeof(Resource))]
}

1. Defina ResourceType del atributo para que busque un recurso

2. Defina el nombre del atributo que se usa para la clave del recurso, después de C # 6.0, puede usarlo nameofpara obtener un soporte de tipo seguro en lugar de codificar la clave.

3. Establece la cultura del hilo actual en el controlador.

Resource.Culture = CultureInfo.GetCultureInfo("zh-CN");

4. Establecer la accesibilidad del recurso al público

5. Mostrar la etiqueta en cshtml como este

@Html.DisplayNameFor(model => model.Age)