我很清楚这个问题已经被回答了，而且OP已经对接受的答案感到满意。但我发现大多数答案，包括公认的答案，都有点复杂。

我有一个项目给了我这样的情况，我能够以这种方式实现它。

首先，你必须考虑枚举名称的大小写:

public enum AuthenticationMethod
{
    Forms = 1,
    WindowsAuthentication = 2,
    SingleSignOn = 3
}

然后，有这个扩展:

using System.Text.RegularExpression;

public static class AnExtension
{
    public static string Name(this Enum value)
    {
        string strVal = value.ToString();
        try
        {
            return Regex.Replace(strVal, "([a-z])([A-Z])", "$1 $2");
        }
        catch
        {
        }
        return strVal;
    }
}

通过这种方法，您可以将每个枚举名称转换为字符串表示形式，每个单词用空格分隔。例:

AuthenticationMethod am = AuthenticationMethod.WindowsAuthentication;
MessageBox.Show(am.Name());

可以使用ToString()引用名称而不是值

Console.WriteLine("Auth method: {0}", AuthenticationMethod.Forms.ToString());

文档在这里:

http://msdn.microsoft.com/en-us/library/16c1xs4z.aspx

.．.如果你在Pascal情况下命名你的枚举(如ThisIsMyEnumValue = 1等)，那么你可以使用一个非常简单的正则表达式来打印友好的形式:

static string ToFriendlyCase(this string EnumString)
{
    return Regex.Replace(EnumString, "(?!^)([A-Z])", " $1");
}

可以很容易地从任何字符串调用:

Console.WriteLine("ConvertMyCrazyPascalCaseSentenceToFriendlyCase".ToFriendlyCase());

输出:

把我疯狂的帕斯卡格句转换成友好格句

这节省了在房子周围运行创建自定义属性并将它们附加到枚举或使用查找表将枚举值与友好字符串结合，最好的是它是自我管理的，可以用于任何Pascal Case字符串，这是无限可重用的。当然，它不允许您使用与解决方案提供的枚举不同的友好名称。

不过，我确实喜欢你针对更复杂场景的原始解决方案。你可以把你的解决方案更进一步，让你的GetStringValue成为你的枚举的扩展方法，然后你就不需要像StringEnum.GetStringValue…

public static string GetStringValue(this AuthenticationMethod value)
{
  string output = null;
  Type type = value.GetType();
  FieldInfo fi = type.GetField(value.ToString());
  StringValue[] attrs = fi.GetCustomAttributes(typeof(StringValue), false) as StringValue[];
  if (attrs.Length > 0)
    output = attrs[0].Value;
  return output;
}

然后你可以直接从你的枚举实例中访问它:

Console.WriteLine(AuthenticationMethod.SSO.GetStringValue());

老帖子，但是…

这个问题的答案其实很简单。使用enumel . tostring()函数

这个函数有6个重载，你可以使用enumenumtostring ("F")或enumenumtostring()来返回字符串值。没必要为其他事操心。这是一个正在运行的演示

注意，这个解决方案可能不适用于所有编译器(这个演示没有像预期的那样工作)，但至少它适用于最新的编译器。

我发现的Enums国际化或从各自的资源文件获取Enums文本的方法是通过继承DescriptionAttribute类创建一个属性类

public class EnumResourceAttribute : DescriptionAttribute
{

    public Type ResourceType { get; private set; }
    public string ResourceName { get; private set; }
    public int SortOrder { get; private set; }
    public EnumResourceAttribute(Type ResourceType,
                         string ResourceName,
                         int SortOrder)
    {

        this.ResourceType = ResourceType;
        this.ResourceName = ResourceName;
        this.SortOrder = SortOrder;
    }
}

创建另一个Static类，为GetString和GetString提供扩展方法。

public static class EnumHelper
{
    public static string GetString(this Enum value)
    {
        EnumResourceAttribute ea =
       (EnumResourceAttribute)value.GetType().GetField(value.ToString())
        .GetCustomAttributes(typeof(EnumResourceAttribute), false)
         .FirstOrDefault();
        if (ea != null)
        {
            PropertyInfo pi = ea.ResourceType
             .GetProperty(CommonConstants.ResourceManager);
            if (pi != null)
            {
                ResourceManager rm = (ResourceManager)pi
                .GetValue(null, null);
                return rm.GetString(ea.ResourceName);
            }

        }
        return string.Empty;
    }


    public static IList GetStrings(this Type enumType)
    {
        List<string> stringList = new List<string>();
        FieldInfo[] fiArray = enumType.GetFields();
        foreach (FieldInfo fi in fiArray)
        {
            EnumResourceAttribute ea =
                (EnumResourceAttribute)fi
                     .GetCustomAttributes(typeof(EnumResourceAttribute), false)
                     .FirstOrDefault();
            if (ea != null)
            {
                PropertyInfo pi = ea.ResourceType
                                    .GetProperty(CommonConstants.ResourceManager);
                if (pi != null)
                {
                    ResourceManager rm = (ResourceManager)pi
                                          .GetValue(null, null);
                    stringList.Add(rm.GetString(ea.ResourceName));
                }
            }
        }
        return stringList.ToList();
    }
}

在Enum的元素上，你可以这样写:

public enum Priority
{
     [EnumResourceAttribute(typeof(Resources.AdviceModule), Resources.ResourceNames.AdviceCreateAdviceExternaPriorityMemberHigh, 1)]
    High,
     [EnumResourceAttribute(typeof(Resources.AdviceModule), Resources.ResourceNames.AdviceCreateAdviceExternaPriorityMemberRoutine, 2)]
    Routine
}

Where Resources.ResourceNames.AdviceCreateAdviceExternaPriorityMemberHigh & resources . resourcename . advicecreateadviceexternaprioritymemberroutine是资源文件中的常量，或者你可以说字符串，其值可以在不同的文化中可用。

如果你在MVC架构中实现你的web应用程序，那么创建一个属性

private IList result;
public IList Result
{
    get
    {
        result = typeof(Priority).GetStrings();
        return result;
    }
}

在你的.cshtml文件中，你可以像这样将枚举绑定到你的下拉列表:

@Html.DropDownListFor(model => Model.vwClinicalInfo.Priority, new SelectList(Model.Result))

谢谢 Ratnesh

当我遇到这样的问题时，我首先会试图找到以下几个问题的答案:

枚举值的名称是否足够友好，或者我需要提供更友好的名称? 我需要往返吗?也就是说，我是否需要将文本值解析为枚举值? 这是我需要为我的项目中的许多枚举做的事情，还是只有一个? 我将在什么样的UI元素中呈现这些信息-特别是，我将绑定到UI，还是使用属性表? 这需要本地化吗?

最简单的方法是使用Enum。GetValue(并使用枚举. parse支持往返)。正如Steve Mitcham所建议的那样，构建一个TypeConverter来支持UI绑定通常也是值得的。(在使用属性表时，没有必要构建TypeConverter，这是属性表的优点之一。尽管天晓得他们也有自己的问题。)

一般来说，如果上述问题的答案表明这是行不通的，我的下一步是创建和填充一个静态Dictionary<MyEnum，字符串>，或者可能是一个Dictionary<Type, Dictionary<int，字符串>>。我倾向于跳过中间的用属性装饰代码的步骤，因为接下来通常需要在部署后更改友好值(通常，但不总是，因为本地化)。

我使用了上述几个建议的组合，并结合了一些缓存。现在，我从网上找到的一些代码中得到了这个想法，但我既不记得是从哪里得到的，也不记得是怎么找到的。所以如果有人发现了一些相似的东西，请在归因处发表评论。

无论如何，使用涉及到类型转换器，所以如果你绑定到UI，它'只是工作'。您可以使用Jakub的模式进行扩展，通过从类型转换器初始化到静态方法来实现快速代码查找。

基本使用量是这样的

[TypeConverter(typeof(CustomEnumTypeConverter<MyEnum>))]
public enum MyEnum
{
    // The custom type converter will use the description attribute
    [Description("A custom description")]
    ValueWithCustomDescription,

   // This will be exposed exactly.
   Exact
}

自定义枚举类型转换器的代码如下:

public class CustomEnumTypeConverter<T> : EnumConverter
    where T : struct
{
    private static readonly Dictionary<T,string> s_toString = 
      new Dictionary<T, string>();

    private static readonly Dictionary<string, T> s_toValue = 
      new Dictionary<string, T>();

    private static bool s_isInitialized;

    static CustomEnumTypeConverter()
    {
        System.Diagnostics.Debug.Assert(typeof(T).IsEnum,
          "The custom enum class must be used with an enum type.");
    }

    public CustomEnumTypeConverter() : base(typeof(T))
    {
        if (!s_isInitialized)
        {
            Initialize();
            s_isInitialized = true;
        }
    }

    protected void Initialize()
    {
        foreach (T item in Enum.GetValues(typeof(T)))
        {
            string description = GetDescription(item);
            s_toString[item] = description;
            s_toValue[description] = item;
        }
    }

    private static string GetDescription(T optionValue)
    {
        var optionDescription = optionValue.ToString();
        var optionInfo = typeof(T).GetField(optionDescription);
        if (Attribute.IsDefined(optionInfo, typeof(DescriptionAttribute)))
        {
            var attribute = 
              (DescriptionAttribute)Attribute.
                 GetCustomAttribute(optionInfo, typeof(DescriptionAttribute));
            return attribute.Description;
        }
        return optionDescription;
    }

    public override object ConvertTo(ITypeDescriptorContext context, 
       System.Globalization.CultureInfo culture, 
       object value, Type destinationType)
    {
        var optionValue = (T)value;

        if (destinationType == typeof(string) && 
            s_toString.ContainsKey(optionValue))
        {
            return s_toString[optionValue];
        }

        return base.ConvertTo(context, culture, value, destinationType);
    }

    public override object ConvertFrom(ITypeDescriptorContext context, 
       System.Globalization.CultureInfo culture, object value)
    {
        var stringValue = value as string;

        if (!string.IsNullOrEmpty(stringValue) && s_toValue.ContainsKey(stringValue))
        {
            return s_toValue[stringValue];
        }

        return base.ConvertFrom(context, culture, value);
    }
}

}