Question

我希望有一个枚举，如：

enum FilterType
{
   Rigid = "Rigid",
   SoftGlow = "Soft / Glow",
   Ghost = "Ghost",
}

如何实现这一目标？有一个更好的方法吗？它将被用于一个对象的实例，它将被序列化/反序列化。它也会填充下拉列表。

Answer 1

using System.ComponentModel;   
enum FilterType
{
    [Description("Rigid")]
    Rigid,
    [Description("Soft / Glow")]
    SoftGlow,
    [Description("Ghost")]
    Ghost ,
}

你可以像这样获得价值

public static String GetEnumerationDescription(Enum e)
{
  Type type = e.GetType();
  FieldInfo fieldInfo = type.GetField(e.ToString());
  DescriptionAttribute[] da = (DescriptionAttribute[])(fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false));
  if (da.Length > 0)
  {
    return da[0].Description;
  }
  return e.ToString();
}

Answer 2

不，但是如果你想要限制“const”字符串并像enum一样使用它们，这就是我的工作：

public static class FilterType
{
   public const string Rigid = "Rigid";
   public const string SoftGlow =  "Soft / Glow";
   public const string Ghost ="Ghost";
}

Answer 3

如果您对扩展方法感到满意，您可以轻松完成您所追求的目标：

//Can return string constants, the results of a Database call, 
//or anything else you need to do to get the correct value 
//(for localization, for example)
public static string EnumValue(this MyEnum e) {
    switch (e) {
        case MyEnum.First:
            return "First Friendly Value";
        case MyEnum.Second:
            return "Second Friendly Value";
        case MyEnum.Third:
            return "Third Friendly Value";
    }
    return "Horrible Failure!!";
}

这样你就可以：

Private MyEnum value = MyEnum.First;
Console.WriteLine(value.EnumValue());

Answer 4

这是不可能的。 C＃只允许整数枚举类型（int，short，long等）。您可以创建一个轻量级的“类enum”类或使用静态常量。

static class FilterTypes
{
    public const string Rigid = "Rigid";
    // ...
}

// or ...

class FilterType
{
    static readonly FilterType RigidFilterType = new FilterType("Rigid");

    string name;

    FilterType(string name)  // private constructor
    {
        this.name = name;
    }

    public static FilterType Rigid
    {
        get { return FilterType.RigidFilterType; }
    }

    // ...
}

Answer 5

枚举始终链接到整数值。所以不行。你可以使用FilterType.Rigid.ToString（）来获取字符串值，尽管它不能直接本地化。

Answer 6

您可以将Enum名称作为此字符串

FilterType myType = FilterType.Rigid;
String strType = myType.ToString();

但是，您可能会遇到Camel Case / Hungarian表示法，但您可以使用这样的方法轻松地将其转换为更加用户友好的字符串（不是最漂亮的解决方案，我会很感激优化这一点的输入）：

Public Shared Function NormalizeCamelCase(ByVal str As String) As String

    If String.IsNullOrEmpty(str) Then
        Return String.Empty
    End If

    Dim i As Integer = 0
    Dim upperCount As Integer = 0
    Dim otherCount As Integer = 0
    Dim normalizedString As String = str

    While i < normalizedString.Length

        If Char.IsUpper(normalizedString, i) Then
            ''Current char is Upper Case
            upperCount += 1
            If i > 0 AndAlso Not normalizedString(i - 1).Equals(" "c) Then
                ''Current char is not first and preceding char is not a space
                ''...insert a space, move to next char
                normalizedString = normalizedString.Insert(i, " ")
                i += 1
            End If
        ElseIf Not Char.IsLetter(normalizedString, i) Then
            otherCount += 1
        End If

        ''Move to next char
        i += 1

    End While

    If upperCount + otherCount = str.Length Then
        ''String is in all caps, return original string 
        Return str
    Else
        Return normalizedString
    End If

End Function

如果仍然不够，您可能需要查看自定义属性，可以使用反射检索...

Answer 7

不，但你可以这样作弊：

public enum FilterType{
   Rigid,
   SoftGlow,
   Ghost
}

然后当你需要他们的字符串值时，你可以做FilterType.Rigid.ToString（）

Answer 8

在System.ComponentModel命名空间中，有一个类DescriptionAttribute在这里运行良好。

enum FilterType
{
   Rigid,
   [Description("Soft / Glow")]
   SoftGlow,
   Ghost,
}

然后获取描述并故障转移到ToString（）

var descriptionAttribute = Value.GetType()
 .GetField(Value.ToString())
 .GetCustomAttributes(typeof(DescriptionAttribute), false)
 .OfType <DescriptionAttribute>()
 .FirstOrDefault()??new DescriptionAttribute(Value.ToString());

Answer 9

这不是完全可能的。但是你可以使用数组伪造它。

首先，按照常规方式创建你的方式：

public enum Regexs
{ 
   ALPHA = 0, 
   NUMERIC = 1, 
   etc.. 
}

然后创建一个数组，其中包含与枚举值对应的值：

private static string[] regexs = new string[]
{
   "[A-Za-z]",
   "[0-9]",
   "etc"...
}

然后你可以通过枚举值访问你的字符串：

public void runit(Regexs myregexEnum)
{
    Regex regex = new Regex( regexs [(int)myregexEnum] );
}

Answer 10

不，这是不可能的。

枚举的批准类型是 byte，sbyte，short，ushort，int，uint，长，或ulong。

但是，您可以使用Enum类检索枚举的声明名称：

string name = Enum.GetName(typeof(FilterType), FilterType.Rigid);

如果这对您不起作用，则可能会在类中收集字符串常量的集合。

Answer 11

您可以在值

上使用属性

[System.ComponentModel.Description("Rigid")]

示例：

 enum FilterType
{
   [System.ComponentModel.Description("Rigid")]
   Rigid,
    [System.ComponentModel.Description("Soft / Glow")]
   SoftGlow,
    [System.ComponentModel.Description("Ghost")]
   Ghost
}

并使用Reflection来获取说明。

枚举扩展方法：

public static string GetDescription(this Enum en)
    {
        var type = en.GetType();
        var memInfo = type.GetMember(en.ToString());

        if (memInfo != null && memInfo.Length > 0)
        {
            var attrs = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
            if (attrs != null && attrs.Length > 0)
                return ((DescriptionAttribute)attrs[0]).Description;
        }
        return en.ToString();
    }

使用它：

FilterType = FilterType.Rigid;
            string description= result.GetDescription();

Answer 12

按照Shaun Bowe的例子你也可以在C＃3中使用枚举的扩展方法（我没有提出也不能，在我的生活中，记住我在哪里）。

创建属性：

public class DisplayTextAttribute : Attribute {
  public DisplayTextAttribute(String text) {
  Text = text;
  }
  public string Text { get; set; }
}

创建扩展程序：

public static class EnumHelpers {
  public static string GetDisplayText(this Enum enumValue) {
    var type = enumValue.GetType();
    MemberInfo[] memberInfo = type.GetMember(enumValue.ToString());

    if (memberInfo == null || memberInfo.Length == 0)
      return enumValue.ToString();

    object[] attributes = memberInfo[0].GetCustomAttributes(typeof(DisplayTextAttribute), false);
    if (attributes == null || attributes.Length == 0)
      return enumValue.ToString();

    return ((DisplayTextAttribute)attributes[0]).Text;
  }
}

我发现这是一个非常整洁的解决方案。在你的枚举中添加以下内容：

enum FilterType{
  Rigid,
  [DisplayText("Soft / Glow")]
  SoftGlow,
  Ghost
}

然后，您可以访问FilterType.GetDisplayText()，它将为未归属的枚举提取字符串，为具有属性的字符串提取displayText。

可能有枚举字符串？

12 个答案: