枚举的泛型类-强制转换问题

本文关键字：转换 问题 泛型类 枚举 | 更新日期: 2023-09-27 18:12:48

我想编写一个接受枚举的泛型类。由于该类旨在实现某些接口，因此主要目的是能够将枚举视为实现这些接口的其他对象(例如:用于列表扩展等)。因此，对于示例enum

public enum QEnum : int
{
    xlNoValue = 0,
    xlSomeValue = 1
}
public static class QEnumExtensions
{
    public static string toString(this QEnum xThis)
    {
        ...
    }
    public static QEnum toEnum(this string xThis)
    {
        ...
    }
}
我想声明一个泛型类，如 
public class QEnumHolder<T>  where T : struct, IConvertible
{
    private T mxVal = default(T);
    public QEnumHolder()
    {
        if (!typeof(T).IsEnum) throw new NotSupportedException();
    }
    public QEnumHolder(T xVal) 
    {
        if (!typeof(T).IsEnum) throw new NotSupportedException();
        mxVal = xVal;
    }
    static public implicit operator QEnumHolder<T>(T xVal)
    {
        return new QEnumHolder<T>(xVal);
    }
    static public implicit operator T(QEnumHolder<T> xVal)
    {
        return (T)xVal.mxVal;
    }
    public string toString()
    {
        if (mxVal is QEnum) return ((QEnum)Convert.ToInt32(mxVal)).toString();     
        ...
     }
    public void fromString(string xString)
    {
        if (mxVal is QEnum)
            mxVal = (???)xString.toEnum();       // problem
    }
}

我们使用的所有枚举都实现了

  • toString()函数，它返回一个"nice"字符串，可以进入组合框等
  • 字符串到枚举的转换，如上

因此toString/toEnum的结构基本是给定的。问题是最后一行代码标有"problem"。我不知道如何告诉编译器，在这个分支中，toEnum()和T的返回类型将是相同的。

我试图通过声明mxVal为int并在任何地方使用Convert.ToInt32来规避这个问题。然而，然后我在operator T中遇到问题，其中编译器反对将int转换为T(编译器不知道T将是enum，因此我不能在SO上使用任何"int到enum转换"讨论)。

枚举的泛型类-强制转换问题

更好的设计是使用一些命名约定，将所有枚举扩展方法放在同一个静态类中，并将这些函数绑定到holder类static构造函数中。像这样:

public static partial class MyEnumExtensions
{
    public static MyEnumHolder<T> ToHolder<T>(this T source)
        where T : struct, IConvertible
    {
        return new MyEnumHolder<T>(source);
    }
}
public class MyEnumHolder<T> where T : struct, IConvertible
{
    static readonly Func<T, string> toStringFunc;
    static readonly Func<string, T> toEnumFunc;
    static MyEnumHolder()
    {
        if (!typeof(T).IsEnum) throw new NotSupportedException();
        // Use your naming conventions
        var name = typeof(T).Name;
        toStringFunc = (Func<T, string>)Delegate.CreateDelegate(typeof(Func<T, string>),
            typeof(MyEnumExtensions).GetMethod("toString", new[] { typeof(T) }));
        toEnumFunc = (Func<string, T>)Delegate.CreateDelegate(typeof(Func<string, T>),
            typeof(MyEnumExtensions).GetMethod("to" + name, new[] { typeof(string) }));
    }
    private T value;
    public MyEnumHolder() { value = default(T); }
    public MyEnumHolder(T value) { this.value = value; }
    static public implicit operator MyEnumHolder<T>(T x) { return new MyEnumHolder<T>(x); }
    static public implicit operator T(MyEnumHolder<T> x) { return x.value; }
    public string toString()
    {
        return toStringFunc(value);
    }
    public void fromString(string xString)
    {
        value = toEnumFunc(xString);
    }
}

示例枚举定义(可以在不同的文件中，但必须在同一个项目中):

public enum MyEnumA { A1, A2, A3 }
partial class MyEnumExtensions
{
    public static string toString(this MyEnumA x)
    {
        //...
        return x.ToString();
    }
    public static MyEnumA toMyEnumA(this string x)
    {
        //...
        return (MyEnumA)Enum.Parse(typeof(MyEnumA), x);
    }
}

和

public enum MyEnumB { B1, B2, B3 }
partial class MyEnumExtensions
{
    public static string toString(this MyEnumB x)
    {
        //...
        return x.ToString();
    }
    public static MyEnumB toMyEnumB(this string x)
    {
        //...
        return (MyEnumB)Enum.Parse(typeof(MyEnumB), x);
    }
}
测试:

var a = MyEnumA.A1.ToHolder();
var sA = a.toString();
a.fromString("A2");
var b = MyEnumB.B2.ToHolder();
var sB = b.toString();
b.fromString("B1");

mxVal = (T)(object)xString.toEnum();
相关文章：