Enum localisation

Vous pouvez mettre en œuvre un attribut de description.

public class LocalizedDescriptionAttribute : DescriptionAttribute
{
     private readonly string _resourceKey;
    private readonly ResourceManager _resource;
    public LocalizedDescriptionAttribute(string resourceKey, Type resourceType)
    {
        _resource = new ResourceManager(resourceType);
        _resourceKey = resourceKey;
    }

    public override string Description
    {
        get
        {
            string displayName = _resource.GetString(_resourceKey);

            return string.IsNullOrEmpty(displayName)
                ? string.Format("[[{0}]]", _resourceKey)
                : displayName;
        }
    }
}

public static class EnumExtensions
{
    public static string GetDescription(this Enum enumValue) 
    {
        FieldInfo fi = enumValue.GetType().GetField(enumValue.ToString());

        DescriptionAttribute[] attributes =
            (DescriptionAttribute[])fi.GetCustomAttributes(
            typeof(DescriptionAttribute),
            false);

        if (attributes != null &&
            attributes.Length > 0)
            return attributes[0].Description;
        else
            return enumValue.ToString();
    }
}

Définir comme ceci:

public enum Roles
{
    [LocalizedDescription("Administrator", typeof(Resource))]
    Administrator,
...
}

Et de l'utiliser comme ceci:

var roles = from RoleType role in Enum.GetValues(typeof(RoleType))
                    select new
                    {
                        Id = (int)role,
                        Name = role.GetDescription()
                    };
 searchModel.roles = new MultiSelectList(roles, "Id", "Name");

Il y a un moyen d'utiliser les attributs de spécifier une chaîne de caractères à utiliser pour les énumérations, lors de l'affichage, mais nous l'avons trouvé trop délicat quand vous avez eu à gérer la localisation.

Donc, ce que nous avons l'habitude de le faire pour les énumérations, qui doivent être localisée est d'écrire une classe d'extension qui fournit une méthode pour obtenir le nom traduit. Vous pouvez simplement utiliser un commutateur qui renvoie des chaînes de l'habitude de ressources. De cette façon, vous fournir les chaînes traduites pour les énumérations, par le biais des ressources, tout comme pour les autres chaînes.

Par exemple:

public enum Role
{
    Administrator,
    Moderator,
    Webmaster,
    Guest
}

public static class RoleExt
{
    public static string AsDisplayString(this Role role)
    {
        switch (role)
        {
            case Role.Administrator: return Resources.RoleAdministrator;
            case Role.Moderator:     return Resources.RoleModerator;
            case Role.Webmaster:     return Resources.RoleWebmaster;
            case Role.Guest:         return Resources.RoleGuest;

            default: throw new ArgumentOutOfRangeException("role");
        }
    }
}

Que vous pouvez utiliser comme ceci:

var role = Role.Administrator;
Console.WriteLine(role.AsDisplayString());

Si vous gardez le RoleExt implémentation de la classe à côté de la enum Role mise en œuvre, il va devenir effectivement une partie de l'interface pour Role. Bien sûr, vous pouvez également ajouter à cette classe tous les autres extensions utiles pour les enum .

[MODIFIER]

Si vous souhaitez gérer plusieurs indicateurs paramètres ("l'Administrateur et le Modérateur ET Webmaster"), alors vous avez besoin de faire les choses un peu différemment:

[Flags]
public enum Roles
{
    None          = 0,
    Administrator = 1,
    Moderator     = 2,
    Webmaster     = 4,
    Guest         = 8
}

public static class RolesExt
{
    public static string AsDisplayString(this Roles roles)
    {
        if (roles == 0)
            return Resources.RoleNone;

        var result = new StringBuilder();

        if ((roles & Roles.Administrator) != 0)
            result.Append(Resources.RoleAdministrator + " ");

        if ((roles & Roles.Moderator) != 0)
            result.Append(Resources.RoleModerator + " ");

        if ((roles & Roles.Webmaster) != 0)
            result.Append(Resources.RoleWebmaster + " ");

        if ((roles & Roles.Guest) != 0)
            result.Append(Resources.RoleGuest + " ");

        return result.ToString().TrimEnd();
    }
}

Que vous pourriez utiliser comme ceci:

Roles roles = Roles.Administrator | Roles.Guest | Roles.Moderator;
Console.WriteLine(roles.AsDisplayString());

Fichiers De Ressources

Fichiers de ressources sont la façon dont vous internationaliser vos chaînes. Pour plus d'informations sur la façon de les utiliser, voir ici:

http://msdn.microsoft.com/en-us/library/vstudio/aa992030%28v=vs.100%29.aspx
http://msdn.microsoft.com/en-us/library/vstudio/756hydy4%28v=vs.100%29.aspx

La méthode d'extension de soufflet, il est travaillé pour moi.

    public static string GetDisplayValue(this Enum value)
    {
        try
        {
            var fieldInfo = value.GetType().GetField(value.ToString());
            var descriptionAttributes = fieldInfo.GetCustomAttributes(typeof(DisplayAttribute), false) as DisplayAttribute[];

            if (descriptionAttributes == null || descriptionAttributes.Length == 0) return value.ToString();

            if (descriptionAttributes[0].ResourceType != null)
            {
                var resource = descriptionAttributes[0].ResourceType.GetProperty("ResourceManager").GetValue(null) as ResourceManager;
                return resource.GetString(descriptionAttributes[0].Name);
            }
            else
            {
                return descriptionAttributes[0].Name;
            }
        }
        catch
        {
            return value.ToString();
        }
    }

Je holpe aide.

L'un des problèmes de la traduction/localisation des enums, c'est que non seulement vous avez à les traduire en spectacle, mais aussi d'analyser les traductions vers la valeur d'enum. La suite C# ce fichier contient comment j'ai surmonté les problèmes de manière deux traductions d'énumérations. Pardon de l'excès de commentaires, mais je ne reçois assez bavard sur mes créations.

//
//EnumExtensions.cs  
//
using System;
using System.Collections.Generic;
namespace EnumExtensionsLibrary
{
///<summary>
///The functions in this class use the localized strings in the resources
///to translate the enum value when output to the UI and reverse--
///translate when receiving input from the UI to store as the actual
///enum value.
///</summary>
///
///<Note>
///Some of the exported functions assume that the ParserEnumLocalizationHolder
///and ToStringEnumLocalizationHolder dictionaries (maps) may contain the enum 
///types since they callthe Initialize methods with the input type before executing.
///</Note>
public static class EnumExtensions
{
#region Exported methods
///<summary>
///Save resource from calling project so that we can look up enums as needed.
///</summary>
///<param name="resourceManager">Where we fish the translated strings from</param>
///<remarks>
///We do not have access to all of the resources from the other projects directly,
///so they must be loaded from the code from within the project.
///</remarks>
public static void RegisterResource(System.Resources.ResourceManager resourceManager)
{
if (!MapOfResourceManagers.Contains(resourceManager))
MapOfResourceManagers.Add(resourceManager);
}
///<summary>
///Parses the localized string value of the enum by mapping it 
///to the saved enum value
///</summary>
///<remarks>
///In some cases, string for enums in the applications may not be translated to the
///localized version (usually when the program presets parameters).  If the enumMap
///doesn't contain the value string, we call to Enum.Parse() to handle the conversion
///or throw an exception.
///</remarks>
///<typeparam name="T"></typeparam>
///<param name="value"></param>
///<exception cref="ArgumentNullException"> enumType or value is null.</exception>
///<exception cref="ArgumentException"> enumType is not an Enum. value is either an 
///empty string or only contains white space, value is a name, but not one of the 
///named constants defined for the enumeration.</exception>
///<exception cref="ArgumentNullException">enumType or value is null.</exception>
///<returns>
///The enum value that matched the input string if found.  If not found, we call 
///Enum.Parse to handle the value.
///</returns>
public static T ParseEnum<T>(this string value) where T : struct
{
ParserInitialize(typeof(T));
var enumMap = ParserEnumLocalizationHolder[typeof(T)];
if (enumMap.ContainsKey(value))
return (T) enumMap[value];
return (T)Enum.Parse(typeof(T), value); 
}
///<summary>
///Parses the localized string value of the enum by mapping it 
///to the saved enum value.  
///</summary>
///<remarks>
///In some cases, string for enums in the applications may not be translated to the
///localized version (usually when the program presets parameters).  If the enumMap
///doesn't contain the value string, we call to Enum.TryParse() to handle the 
///conversion. and return.
///</remarks>
///<typeparam name="T"></typeparam>
///<param name="value"></param>
///<param name="result"></param>
///<returns>
///Returns true if the enum mapping contains the localized string value and the data 
///in the returned result parameter will be a valid value of that enum type. if the
///string value is not mapped, then calls Enum.TryParse to handle the conversion and 
///return result.
///</returns>
public static bool TryParseEnum<T>(this string value, out T result) where T : struct
{
ParserInitialize(typeof(T));
var enumMap = ParserEnumLocalizationHolder[typeof(T)];
if (!enumMap.ContainsKey(value))
return Enum.TryParse(value, out result);
result = (T)enumMap[value];
return true;
}
///<summary>
///Converts the enum value to a localized string.
///</summary>
///<typeparam name="T">must be an enum to work</typeparam>
///<param name="value">is an enum</param>
///<returns>
///The localized string equivalent of the input enum value
///</returns>
public static string EnumToString<T>(this T value) where T : struct
{
ToStringInitialize(typeof(T));
var toStringMap = ToStringEnumLocalizationHolder[typeof(T)];
return toStringMap.ContainsKey(value) ? toStringMap[value] : value.ToString();
//return EnumDescription(value);
}
///<summary>
///Gathers all of the localized translations for each 
///value of the input enum type into an array
///</summary>
///<remarks>
///The return array from Type.GetEnumValues(), the array elements are sorted by 
///the binary values (that is, the unsigned values) of the enumeration constants.
///</remarks>
///<param name="enumType"></param>
///<exception cref="ArgumentException"> The current type is not an enumeration.</exception>
///<returns>
///A string array with the localized strings representing
///each of the values of the input enumType.
///</returns>
public static string[] AllDescription(this Type enumType)
{
ToStringInitialize(enumType);
var descriptions = new List<string>();
var values = enumType.GetEnumValues();
var toStringMap = ToStringEnumLocalizationHolder[enumType];
foreach (var value in values)
{
descriptions.Add(toStringMap.ContainsKey(value) ? toStringMap[value] : value.ToString());
}
return descriptions.ToArray();
}
#endregion
#region Helper methods
///<summary>
///Translates an enum value into its localized string equivalent
///</summary>
///<remarks>
///This assumes that the "name" for the localized string in the 
///resources will look like "enum-type-name""value".  For example,  
///if I have an enum setup as:
///
///    enum Days {Sat, Sun, Mon, Tue, Wed, Thu, Fri};
///
///the value "Sun" in the enum must have the name: "DaysSun"
///in the resources. The localized (translated) string will
///be in the value field.  E.g.,
///
/// <data name="DaysSun" xml:space="preserve">
///<value>Sunday</value>
/// </data>    
///
///2nd note: there may be multiple resources to pull from.
///Will look in each resource until we find a match or 
///return null.
///</remarks>
///<typeparam name="T"></typeparam>
///<param name="enumType">the enum type</param>
///<param name="value">the specific enum value</param>
///<returns>
///If the enum value is found in the resources, then return 
///that string.  If not, then return null. 
///</returns>
private static string LocalEnumDescription<T>(Type enumType, T value)
{
foreach (var resourceManager in MapOfResourceManagers)
{
//The following live line uses string interpolation to perform:
//var rk = string.Format("{0}{1}", enumType.Name, value);
var rk = $"{enumType.Name}{value}";
//Given the above string formatting/interpolation, neither the enum.Name 
//nor the value will have a '.' so we do not have to remove it.
var result = resourceManager.GetString(rk);
if (!string.IsNullOrEmpty(result))
return result;
}
return null;
}
///<summary>
///Initializes the mapping of the enum type to its mapping of localized strings to 
///the enum's values.
///</summary>
///<remarks>
///The reason for each enum type to have a mapping from the localized string back 
///to its values is for ParseEnum and TryParseEnum to quickly return a value rather
///than doing a lengthy loop comparing each value in the resources.
///
///Also, we only map the corresponding resource string if it exists in the resources.
///If not in the resources, then we call the Enum methods Parse() and TryParse() to
///figure the results and throw the appropriate exception as needed.
///</remarks>
///
///<param name="enumType"></param>
private static void ParserInitialize(Type enumType)
{
if (!ParserEnumLocalizationHolder.ContainsKey(enumType))
{
var values = enumType.GetEnumValues();  //See remark for AllDescription().
var enumMap = new Dictionary<string, object>();
foreach (var value in values)
{
var description = LocalEnumDescription(enumType, value);
if (description != null)
enumMap[description] = value;
}
ParserEnumLocalizationHolder[enumType] = enumMap;
}
}
///<summary>
///Initializes the mapping of the enum type to its mapping of the enum's values
///to their localized strings.
///</summary>
///<remarks>
///The reason for each enum type to have a mapping from the localized string to its
///values is for AllDescription and EnumToString to quickly return a value rather 
///than doing a lengthy loop runing through each of the resources.
///
///Also, we only map the corresponding resource string if it exists in the resources.
///See the EnumDescription method for more information.
///</remarks>
///
///<param name="enumType"></param>
private static void ToStringInitialize(Type enumType)
{
if (!ToStringEnumLocalizationHolder.ContainsKey(enumType))
{
var values = enumType.GetEnumValues();  //See remark for AllDescription().
var enumMap = new Dictionary<object, string>();
foreach (var value in values)
{
var description = LocalEnumDescription(enumType, value);
if (description != null)
enumMap[value] = description;
}
ToStringEnumLocalizationHolder[enumType] = enumMap;
}
}
#endregion
#region Data
private static readonly List<System.Resources.ResourceManager> MapOfResourceManagers =
new List<System.Resources.ResourceManager>();
private static readonly Dictionary<Type, Dictionary<string, object>> ParserEnumLocalizationHolder =
new Dictionary<Type, Dictionary<string, object>>();
private static readonly Dictionary<Type, Dictionary<object, string>> ToStringEnumLocalizationHolder =
new Dictionary<Type, Dictionary<object, string>>();
#endregion
}
}

Cela ne nécessite pas un attribut de l'avant de chaque valeur d'enum, mais nécessite que le nom de l'attribut de la traduction de votre enum chaîne dans les ressources est mis en forme telles que c'est une concaténation de la enum type-le nom et la valeur d'enum. Voir le commentaire ci-dessus la LocalEnumDescription méthode pour plus d'informations. En outre, il conserve les traductions des énumérations (à la fois en avant et en arrière) par la cartographie de leurs traductions telles que nous n'avons pas besoin de chercher la traduction à chaque fois que nous rencontrons une valeur d'enum.

Espérons-le, il est assez facile à comprendre et à utiliser.

Même réponse que accepté de répondre, mais sans avertissements d'analyse du code

 [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1019:DefineAccessorsForAttributeArguments", Justification ="Resourcetype is only needed to instantiate Resource manager, and ResourceManager is exposed")]
[AttributeUsage(AttributeTargets.All)]
public sealed class LocalizedDescriptionAttribute 
: DescriptionAttribute
{
private readonly string _resourceKey;
private readonly ResourceManager _resourceManager;
public LocalizedDescriptionAttribute(string resourceKey, Type resourceType)
{
_resourceManager = new ResourceManager(resourceType);
_resourceKey = resourceKey;
}
public string ResourceKey
{
get { return _resourceKey; }
}
public ResourceManager ResourceManager
{
get { return _resourceManager; }
}
public override string Description
{
get
{
string displayName = _resourceManager.GetString(_resourceKey);
return string.IsNullOrEmpty(displayName)? string.Format(CultureInfo.CurrentUICulture ,"[[{0}]]", _resourceKey) : displayName;
}
}
}
public static class EnumExtensions
{
public static string GetDescription(this Enum enumValue)
{
if (enumValue == null)
{
throw new ArgumentNullException("enumValue");
}
FieldInfo fi = enumValue.GetType().GetField(enumValue.ToString());
DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attributes != null && attributes.Length > 0)
{
return attributes[0].Description;
}
else
{
return enumValue.ToString();
}
}
}

public enum RoleEnum
{
Administrator = 4,
Official = 1,
Trader = 3,
HeadOfOffice = 2
}
public static class RoleEnumExtension
{
private static readonly ResourceManager Resource =
new ResourceManager("Project.CommonResource", typeof(CommonResource).Assembly);
public static string Display(this RoleEnum role)
{
return Resource.GetString("RoleType_" + role);
}
}

Vous pouvez l'utiliser comme

RoleEnum.Administrator.Display()

Espère que cela aidera à quelqu'un

Vous pouvez utiliser Lexicale.Localisation1 qui permet d'intégrer la valeur par défaut et la culture des valeurs spécifiques dans le code, et de développer en externe fichiers de localisation (comme .en json .resx ou .ini) pour de plus amples cultures.

namespace Library
{
enum Permissions
{
Create = 1,
Drop = 2,
Modify = 4,
GrantCreate = 8,
GrantDrop = 16,
GrantModify = 32
}
}

Code du Programme:

//Load localization.ini
LineRoot.Builder.AddLocalizationFile("localization.ini").Build();
//Create key for enum
ILine key = LineRoot.Global.Assembly("ConsoleApp4").Type<Permissions>().Format("{0}");
//Print 
Console.WriteLine(key.Value(Permissions.Create | Permissions.Drop));
Console.WriteLine(key.Value(Permissions.Create | Permissions.Drop).Culture("en"));
Console.WriteLine(key.Value(Permissions.Create | Permissions.Drop).Culture("fi"));

localisation.ini:

[Assembly:ConsoleApp4:Type:Library.Permissions:Culture:fi]
Key:Create = Luonti
Key:Drop = Poisto
Key:Modify = Muutos
Key:GrantCreate = Luonnin myöntö
Key:GrantDrop = Poiston myöntö
Key:GrantModify = Muutoksen myöntö
[Assembly:ConsoleApp4:Type:Library.Permissions:Culture:en]
Key:Create = Create
Key:Drop = Drop
Key:Modify = Modify
Key:GrantCreate = Grant Create
Key:GrantDrop = Grant Drop
Key:GrantModify = Grant Modify 

1 (je suis responsable de la bibliothèque)