Eu tenho um aplicativo localizado e estou me perguntando se é possível ter a DisplayNamepropriedade de um determinado modelo definida em um Recurso.

Eu gostaria de fazer algo assim:

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

Mas não posso, pois o compilador diz: "Um argumento de atributo deve ser uma expressão constante, tipo de expressão ou expressão de criação de matriz de um tipo de parâmetro de atributo" :(

Existem soluções alternativas? Estou produzindo etiquetas manualmente, mas preciso delas para a saída do validador!

Que tal escrever um 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 poderia ser usado assim:

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

Se você usar o MVC 3 e o .NET 4, poderá usar o novo Displayatributo no System.ComponentModel.DataAnnotationsespaço para nome. Este atributo substitui o DisplayNameatributo e fornece muito mais funcionalidade, incluindo suporte à localização.

No seu caso, você usaria assim:

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

Como uma observação lateral, este atributo não funcionará com recursos internos App_GlobalResourcesou App_LocalResources. Isso tem a ver com a ferramenta personalizada ( GlobalResourceProxyGenerator) usada por esses recursos. Em vez disso, verifique se o arquivo de recurso está definido como 'Recurso incorporado' e use a ferramenta personalizada 'ResXFileCodeGenerator'.

(Como uma observação adicional, você não deve estar usando App_GlobalResourcesou App_LocalResourcescom o MVC. Você pode ler mais sobre por que esse é o caso aqui )

Se você abrir o arquivo de recursos e alterar o modificador de acesso para público ou interno, ele gerará uma classe a partir do arquivo de recursos, o que permitirá criar referências de recursos fortemente tipadas.

O que significa que você pode fazer algo assim (usando o C # 6.0). Então você não precisa se lembrar se o primeiro nome estava em minúsculas ou em camelcased. E você pode ver se outras propriedades usam o mesmo valor de recurso com uma localização de todas as referências.

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

Atualizar:

Sei que é tarde demais, mas gostaria de adicionar esta atualização:

Estou usando o Provedor de Metadados do Modelo Convencional, apresentado por Phil Haacked, que é mais poderoso e fácil de aplicar. Confira: ConventionalModelMetadataProvider

Resposta antiga

Aqui, se você deseja oferecer suporte a muitos 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);
        }
    }
}

Em seguida, use-o assim:

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

Para o tutorial completo de localização, consulte esta página .

Eu recebi a resposta do Gunders trabalhando com meu App_GlobalResources escolhendo as propriedades dos recursos e alterne "Ferramenta Personalizada" para "PublicResXFileCodeGenerator" e crie uma ação para "Recurso Incorporado". Observe o comentário do Gunders abaixo.

Funciona como um encanto :)

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 do atributo para procurar um recurso

2. Defina o Nome do atributo que é usado para a chave do recurso, após o C # 6.0, você pode usar nameofpara suporte de tipo forte em vez de codificar a chave.

3. Defina a cultura do segmento atual no controlador.

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

4. Defina a acessibilidade do recurso para público

5. Exiba o rótulo em cshtml como este

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