Lokalizacja atrybutu opisów enum

Question

Jaki jest najlepszy sposób na zlokalizowanie opisów wyliczeń w .net?

(Patrz Adding descriptions to enumeration constants w opisach enum przykład)

Idealnie chciałbym coś, co wykorzystuje ResourceManager i plików zasobów, dlatego pasuje jak inne obszary aplikacji są zlokalizowane.

Answer 1

To właśnie z skończyło się, nie widzę wartość w dodawaniu niestandardowego klasę atrybutu posiadać klucz zasobów, a następnie wyszukiwanie w plikach zasobów - dlaczego nie użyć po prostu enums nazwa_tabela + wartość jako klucza zasobów?

using System; 
using System.Resources; 
using System.Reflection; 

public class MyClass 
{ 
    enum SomeEnum {Small,Large}; 

    private ResourceManager _resources = new ResourceManager("MyClass.myResources", 
          System.Reflection.Assembly.GetExecutingAssembly());  

    public string EnumDescription(Enum enumerator) 
    {  
    string rk = String.Format("{0}.{1}",enumerator.GetType(),enumerator); 
    string localizedDescription = _resources.GetString(rk); 

    if (localizedDescription == null) 
     { 
     // A localized string was not found so you can either just return 
     // the enums value - most likely readable and a good fallback. 
     return enumerator.ToString(); 

     // Or you can return the full resourceKey which will be helpful when 
     // editing the resource files(e.g. MyClass+SomeEnum.Small) 
     // return resourceKey; 
     } 
    else 
     return localizedDescription; 
    } 


    void SomeRoutine() 
    { 
    // Looks in resource file for a string matching the key 
    // "MyClass+SomeEnum.Large" 
    string s1 = EnumDescription(SomeEnum.Large);  
    } 
} 

Answer 2

Istnieje proste rozwiązanie: użyj atrybutu LocalizedDescription, aby przekazać klucz zasobów.

[Serializable] 
    public class LocalizableDescriptionAttribute:DescriptionAttribute 
    { 
     public LocalizableDescriptionAttribute(string resourceKey) 
      :base(Resources.ResourceManager.GetString(resourceKey)) 
     { } 

    } 

Answer 3

Zobacz mój przykład stół w tej kwestii: Mapy typu

Localisation/I18n of database data in LINQ to SQL

Stan tabeli na wyliczenie wartości. Prawdziwa korzyść polega na tym, że możesz zlokalizować swoje raporty i aplikacje, a także określić zewnętrzne identyfikatory do integracji z osobami trzecimi, które nie chcą wartości wewnętrznych itp. Oddziela opis enum od jego wartości.

Answer 4

Nie można zastosować wielu opcji System.ComponentModel.DescriptionAttribute (aby opcja była wyłączona).

Dodaj więc poziom pośredni, opis zawiera nazwę zasobu, a następnie użyj wsparcia lokalizacji w zasobach. Najwyraźniej użytkownicy enum będą musieli wywołać metodę pomocnika, aby to zrobić.

Answer 5

Jednym ze sposobów, które zrobiłem raz, było dodanie metody rozszerzania w tej samej przestrzeni nazw co wyliczenie, które zwróciło ciąg znaków. W moim przypadku było to po prostu na stałe, ale nie byłoby problemu z ich pobraniem z pliku zasobów.

public static string Describe(this SomeEnum e) 
    { 
     switch(e) 
     { 
      SomeEnum.A: 
       return "Some text from resourcefile"; 
      SomeEnum.B: 
       return "Some other text from resourcefile"; 
      ...: 
       return ...; 
     } 
    } 

nie

Może wyjątkowo gładka lub fantazyjne rozwiązanie, ale działa =)

Answer 6

Moje rozwiązanie, wykorzystując natywne atrybut OPIS: Deklaracja

public class LocalizedEnumAttribute : DescriptionAttribute 
{ 
    private PropertyInfo _nameProperty; 
    private Type _resourceType; 

    public LocalizedEnumAttribute(string displayNameKey) 
     : base(displayNameKey) 
    { 

    } 

    public Type NameResourceType 
    { 
     get 
     { 
      return _resourceType; 
     } 
     set 
     { 
      _resourceType = value; 

      _nameProperty = _resourceType.GetProperty(this.Description, BindingFlags.Static | BindingFlags.Public); 
     } 
    } 

    public override string Description 
    { 
     get 
     { 
      //check if nameProperty is null and return original display name value 
      if (_nameProperty == null) 
      { 
       return base.Description; 
      } 

      return (string)_nameProperty.GetValue(_nameProperty.DeclaringType, null); 
     } 
    } 
} 

public static class EnumExtender 
{ 
    public static string GetLocalizedDescription(this Enum @enum) 
    { 
     if (@enum == null) 
      return null; 

     string description = @enum.ToString(); 

     FieldInfo fieldInfo = @enum.GetType().GetField(description); 
     DescriptionAttribute[] attributes = (DescriptionAttribute[])fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false); 

     if (attributes.Any()) 
      return attributes[0].Description; 

     return description; 
    } 
} 

wyliczenia

public enum MyEnum 
{ 
    [LocalizedEnum("ResourceName", NameResourceType = typeof(ResourceType))] 
    Test = 0 
} 

Następnie zadzwonić MyEnumInstance.GetLocalizedDescription()

Answer 7

Wygląda to dobre: ​​http://www.codeproject.com/Articles/19980/Data-Binding-an-Enum-with-Descriptions

Answer 8

Zamień metodę @ nairik na następującą, aby dodać obsługę znaczników flagi.

public static string GetLocalizedDescription(this Enum @enum) 
{ 
    if (@enum == null) 
     return null; 

    StringBuilder sbRet = new StringBuilder(); 

    string description = @enum.ToString(); 

    var fields = description.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); 

    foreach (var field in fields) 
    { 
     FieldInfo fieldInfo = @enum.GetType().GetField(field); 
     DescriptionAttribute[] attributes = (DescriptionAttribute[])fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false); 

     if (attributes.Any()) 
      sbRet.AppendFormat("{0}, ", attributes[0].Description); 
     else 
      sbRet.AppendFormat("{0}, ", field); 
    } 

    if (sbRet.Length > 2) 
     sbRet.Remove(sbRet.Length - 2, 2); 

    return sbRet.ToString(); 
} 

i zastąpić NameResourceType w atrybucie:

public Type NameResourceType 
{ 
    get 
    { 
     return _resourceType; 
    } 
    set 
    { 
     _resourceType = value; 

     _nameProperty = _resourceType.GetProperty(base.Description, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); 
    } 
}