2

我enums的数据库中有以下内容：

“随机类型”、“随机类型 1”、“新随机”

通常，我会表示枚举中的值，例如：

enum myTypes
{
   Random Type = 0,...
}

但这是不可能的，所以我尝试使用一个类

static class myTypes
{
    public const string RandomType = "Random Type";
    public const string NewRandom = "NewRandom";
}

这样，我可以像 一样使用类Enum，但我想知道这是否是最好的实现？或者周围有没有创造Enums空间？

谢谢。

编辑： 拜托，我也很想知道我当前的实现是否有任何问题。我感觉我目前的实现比这里建议的大多数解决方案都要好。

谢谢

4

6 回答 6

3

不，你不能那样做。枚举只是类型安全int的。

有一个可用的解决方案，我非常喜欢它。使用DescriptionAttribute。

你会这样使用它：

static enum myTypes
{
    [Description("Random Type")]
    RandomType,
    [Descripton("New Random")]
    NewRandom
}

然后你还需要这个扩展方法：

public static string GetDescription<T>(this T en) where T : struct, IConvertible
{
    Type type = typeof(T);
    if (!type.IsEnum)
    {
        throw new ArgumentException("The type is not an enum");
    }
    MemberInfo[] memInfo = type.GetMember(en.ToString());
    if (memInfo != null && memInfo.Length > 0)
    {
        object[] attrs = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
        if (attrs != null && attrs.Length > 0)
        {
            return ((DescriptionAttribute)attrs[0]).Description;
        }
    }
    return en.ToString();
}

然后，你可以这样做：

myTypes.RandomType.GetDescription();
于 2013-06-23T10:24:38.880 回答
2

枚举与数字（特别是整数）非常相似，而不是字符串左右。坚持编号枚举可以让您轻松转换、标志组合（例如 AND、OR 等）。

我不会使用字符串常量代替枚举，除非这会给您带来比惩罚更多的好处。

如果您的目标是向用户描述 Enum 选项，我建议考虑使用Description属性来丰富每个项目。它是元数据，而不是真实数据，但使用反射也很容易阅读。

干杯

于 2013-06-23T09:59:38.377 回答
2

我所做的是定义[DisplayName(string)]可以附加到枚举值的自定义属性。您在希望用空格/特殊字符命名的值上使用显示名称定义枚举：

public enum Test
{
    None = 0,

    [DisplayName("My Value")]
    MyValue = 1,

    [DisplayName("Spęćiał")]
    Special = 2
}

除了获取枚举值名称之外，您的实现还应检查是否DisplayName设置了属性，如果是，则应改为显示名称。

于 2013-06-23T10:18:29.727 回答
1

我会使用显示名称属性：

[AttributeUsage(AttributeTargets.Field)]
public class EnumDisplayNameAttribute : DisplayNameAttribute
{
    public EnumDisplayNameAttribute()
        : base(string.Empty)
    {
    }

    public EnumDisplayNameAttribute(string displayName)
        : base(displayName)
    {
    }
}


public static class EnumExtensions
{
    public static string ToDisplayName(this Enum enumValue)
    {
        var builder = new StringBuilder();

        var fields = GetEnumFields(enumValue);

        if (fields[0] != null)
            for (int i = 0; i < fields.Length; i++)
            {
                var value = fields[i]
                    .GetCustomAttributes(typeof(EnumDisplayNameAttribute), false)
                    .OfType<EnumDisplayNameAttribute>()
                    .FirstOrDefault();

                builder.Append(value != null
                                   ? value.DisplayName
                                   : enumValue.ToString());

                if (i != fields.Length - 1)
                    builder.Append(", ");
            }

        return builder.ToString();
    }

    private static FieldInfo[] GetEnumFields(Enum enumValue)
    {
        var type = enumValue.GetType();

        return enumValue
            .ToString()
            .Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries)
            .Select(type.GetField)
            .ToArray();
    }
}

类型的用法：

public enum MyType
{
    [DisplayName("Random Type")]
    RandomType,
    [DisplayName("New Random")]
    NewRandom
}

将会：

var enumVariable = MyType.RandomType;
var stringRepresentation = enumVariable.ToDisplayName();

请注意，如果您省略某些枚举成员的属性，则使用这种方法您将获得 ToString 值。

于 2013-06-23T10:21:18.030 回答
0

您可以使用Typesafe Enum模式来实现您的目标。

想法是将您的枚举包装在一个类周围。我想这就是你想要的 -

public class MyTypes
{
    #region Enum Values

    public static MyTypes RandomType = new MyTypes(0, "Random Type");
    public static MyTypes NewRandom = new MyTypes(1, "New Random");

    #endregion

    #region Private members

    private int id;
    private string value;
    private MyTypes(int id, string value)
    {
        this.id = id;
        this.value = value;
    }

    #endregion

    #region Overriden members

    public override string ToString()
    {
        return value;
    }

    #endregion

    public static List<MyTypes> GetValues()
    {
        return new List<MyTypes>() { MyTypes.RandomType, MyTypes.NewRandom };
    }
}
于 2013-06-23T10:59:59.800 回答
0

您可能不应该在数据库中使用字符串作为类型指示符。请改用整数。如果你喜欢，你可以在你的数据库中有一个“类型表”，你可以在其中存储类型名称，而不是在使用它们的表中重复它们。

如果你这样做，那么你可以将数据库中的整数转换为上面建议的枚举。

于 2013-06-23T10:16:38.080 回答