模拟实现接口的枚举的行为

Question

假设我有一个类似的枚举：

enum OrderStatus
{
    AwaitingAuthorization,
    InProduction,
    AwaitingDespatch
}

我还在枚举上创建了一个扩展方法来整理 UI 中显示的值，所以我有类似的东西：

public static string ToDisplayString(this OrderStatus status)
{
    switch (status)
    {
        case Status.AwaitingAuthorization:
            return "Awaiting Authorization";

        case Status.InProduction:
            return "Item in Production";

        ... etc
    }
}

受到优秀帖子的启发 此处，我想将我的枚举绑定到 SelectList 具有扩展方法：

public static SelectList ToSelectList(this TEnum enumObj)

但是，要在 UI 下拉列表中使用 DisplayString 值，我需要添加一个约束沿着

: where TEnum has extension ToDisplayString

显然，这些都不适用于当前的方法，除非有一些我不知道的聪明技巧。

有人对我如何实现这样的事情有任何想法吗？

Answer 1

是否有令人信服的理由在这里使用 enum ？

当您开始疯狂地使用枚举时，可能是时候使用类了。

public class OrderStatus
{
    OrderStatus(string display) { this.display = display; }

    string display;

    public override string ToString(){ return display; }

    public static readonly OrderStatus AwaitingAuthorization
        = new OrderStatus("Awaiting Authorization");
    public static readonly OrderStatus InProduction
        = new OrderStatus("Item in Production");
    public static readonly OrderStatus AwaitingDispatch
        = new OrderStatus("Awaiting Dispatch");
}

您使用它的方式与enum 相同：

public void AuthorizeAndSendToProduction(Order order, ProductionQueue queue)
{
    if(order.Status != OrderStatus.AwaitingAuthorization) 
    {
        Console.WriteLine("This order is not awaiting authorization!");
        return;
    }
    order.Status = OrderStatus.InProduction;
    queue.Enqueue(order);
}

字符串表示形式是内置的，您所需要的只是ToString()。

Answer 2

当然，您可以使用 DisplayAttribute 来注释您的 Enum。

enum OrderStatus
{
    [Display(Description="Long Desc", Name="Awaiting Authorization", ShortName="Wait Auth")]
    AwaitingAuthorization,

    [Display(Description="...", Name="...", ShortName="...")]
    InProduction,

    [Display(Description="...", Name="...", ShortName="...")]       
    AwaitingDespatch
}

您还可以选择创建一个扩展方法，该方法采用任何枚举值并根据设置的属性返回其显示名称，以整理 UI 中显示的值，如下所示：

public static class EnumExtensions
{
    public static string ToName(this Enum enumValue)
    {
        var displayAttribute = enumValue.GetType()
            .GetMember(enumValue.ToString())[0]
            .GetCustomAttributes(false)
            .Select(a => a as DisplayAttribute)
            .FirstOrDefault();
        return displayAttribute?.Name ?? enumValue.ToString();
    }
}

使用

public enum Test
{
    [Display(Name="AAA")]
    a,
    b
}

代码：

Console.WriteLine(Test.a.ToName());
Console.WriteLine(Test.b.ToName());

结果

AAA

b

我想使用扩展方法将我的枚举绑定到 SelectList：

为了类型安全，我不会使用扩展方法，而是使用处理 Enum 类型的静态类：

C# 7.3 之前的版本。由于 Enum 在 7.3 之前不是有效的类型约束（并且会导致编译时异常），因此您最终会认为枚举是值类型，并且它们实现了一些接口，以便将类型参数限制为尽可能接近Enum。

public static class Enums<TEnum> where TEnum : struct, IComparable, IFormattable, IConvertible
{
    static Enums()
    {
        if (!typeof(TEnum).IsEnum)
        {
            throw new InvalidOperationException();
        }
    }
}

C# 7.3+ 版本，带有编译时间检查...耶！

public static class Enums<TEnum> where TEnum : Enum
{
}

类的 GetValues 方法：

public static IEnumerable<TEnum> GetValues(bool includeFirst)
{
    var result = ((TEnum[])Enum.GetValues(typeof(TEnum))).ToList();
    if (!includeZero)
        result = result.Where(r => r != default).ToList();
    return result;
}

如果您遵循枚举指南 并包含默认（零）值，我们可以忽略它（有时我们想显示“未选择”之类的值，有时我们不想显示“无效选择”）。

然后我们可以添加另一个方法：

public static IEnumerable<string> GetNames(bool includeFirst)
{
    var result = GetValue(includeFirst)
       .Select(v => v.ToName())
       .ToList();
    return result;
}

Answer 3

不要使用“ToDisplayString”，只需覆盖枚举的 ToString() 即可。因此，如果枚举覆盖它，它将采用它，否则它将采用默认的 ToString 行为（在 ToSelectList 中）。

Answer 4

如果您只需要使用相对较小的枚举类，这些类仅具有显式转换运算符 ToString，并且对于 System 及其派生命名空间上的枚举的特殊类不需要其他可用性，那么以下内容示例可能是一个解决方案：

namespace MyNamespace {
    public abstract class EnumerateClass<Type, InheritingClass> : IEquatable<InheritingClass>
        where Type : IEquatable<Type>
        where InheritingClass : EnumerateClass<Type, InheritingClass> {

        internal readonly Type Identifier;

        protected EnumerateClass (Type identifier) {
            this.Identifier = identifier;
        }
        public bool Equals(InheritingClass obj)
            => this.Identifier.Equals(obj.Identifier);
        public static explicit operator Type(EnumerateClass<Type, InheritingClass> obj)
            => obj.Identifier;
    }
    public sealed class MyNumber : EnumerateClass<int, MyNumber> {

        private MyNumber(int identifier) : base(identifier) { }

        public static readonly MyNumber None = new Number(0);
        public static readonly MyNumber One = new Number(1);
        public static readonly MyNumber Two = new Number(2);
        ...

        public override string ToString() {
            switch (this.Identifier) {
                case 0: return "None";
                case 1: return "One";
                case 2: return "Two";
                ...
            }
        }
    }
}

Answer 5

您可以这样做：

public static string ToOrderStatusDisplayString(this Enum status)
{    
    switch ((OrderStatus)status)
    {
         ...
    }
}

然后将 TEnum 限制为 Enum： where TEnum : System.Enum

当然，这样您就可以在 Enum 本身上获得一堆方法并失去类型安全性。