我知道我来这个派对有点晚了，但这是我的意见。

我们都很清楚，框架不支持Enum继承。在这篇文章中提出了一些非常有趣的解决办法，但没有一个是我想要的，所以我自己尝试了一下。

介绍:ObjectEnum

您可以在这里查看代码和文档:https://github.com/dimi3tron/ObjectEnum。

软件包在这里:https://www.nuget.org/packages/ObjectEnum

或者直接安装它:install - package ObjectEnum

简而言之，ObjectEnum<TEnum>充当任何enum的包装器。通过重写子类中的GetDefinedValues()，可以指定哪些enum值对这个特定的类有效。

添加了许多操作符重载，以使ObjectEnum<TEnum>实例的行为就像底层枚举的实例一样，记住已定义的值限制。这意味着您可以轻松地将实例与int或enum值进行比较，从而在开关情况或任何其他条件中使用它。

我想参考上面提到的github回购的例子和进一步的信息。

我希望这对你有用。请随意评论或在github上打开一个问题以获得进一步的想法或评论。

下面是几个简短的例子，说明你可以用ObjectEnum<TEnum>做什么:

var sunday = new WorkDay(DayOfWeek.Sunday); //throws exception
var monday = new WorkDay(DayOfWeek.Monday); //works fine
var label = $"{monday} is day {(int)monday}." //produces: "Monday is day 1."
var mondayIsAlwaysMonday = monday == DayOfWeek.Monday; //true, sorry...

var friday = new WorkDay(DayOfWeek.Friday);

switch((DayOfWeek)friday){
    case DayOfWeek.Monday:
        //do something monday related
        break;
        /*...*/
    case DayOfWeek.Friday:
        //do something friday related
        break;
}

忽略base是保留字的事实，你不能继承enum。

你能做的最好的事情就是这样:

public enum Baseenum
{
   x, y, z
}

public enum Consume
{
   x = Baseenum.x,
   y = Baseenum.y,
   z = Baseenum.z
}

public void Test()
{
   Baseenum a = Baseenum.x;
   Consume newA = (Consume) a;

   if ((Int32) a == (Int32) newA)
   {
   MessageBox.Show(newA.ToString());
   }
}

因为它们都是相同的基类型(即:int)，你可以将一个类型的实例的值赋给另一个类型，这就是强制转换。虽然不理想，但很有效。

你可以通过类实现你想要的:

public class Base
{
    public const int A = 1;
    public const int B = 2;
    public const int C = 3;
}
public class Consume : Base
{
    public const int D = 4;
    public const int E = 5;
}

现在你可以像使用枚举一样使用这些类:

int i = Consume.B;

更新(在您更新问题后):

如果你将相同的int值赋给现有枚举中定义的常量，那么你可以在枚举和常量之间进行类型转换，例如:

public enum SomeEnum // this is the existing enum (from WSDL)
{
    A = 1,
    B = 2,
    ...
}
public class Base
{
    public const int A = (int)SomeEnum.A;
    //...
}
public class Consume : Base
{
    public const int D = 4;
    public const int E = 5;
}

// where you have to use the enum, use a cast:
SomeEnum e = (SomeEnum)Consume.B;

上述使用int常量类的解决方案缺乏类型安全。也就是说，你可以发明一些在课堂上没有定义的新值。 此外，举例来说，编写以这些类之一作为输入的方法是不可能的。

你需要写

public void DoSomethingMeaningFull(int consumeValue) ...

但是，在以前的Java中有一个基于类的解决方案，当时没有可用的枚举。这提供了几乎类似枚举的行为。唯一需要注意的是，这些常量不能在switch语句中使用。

public class MyBaseEnum
{
    public static readonly MyBaseEnum A = new MyBaseEnum( 1 );
    public static readonly MyBaseEnum B = new MyBaseEnum( 2 );
    public static readonly MyBaseEnum C = new MyBaseEnum( 3 );

    public int InternalValue { get; protected set; }

    protected MyBaseEnum( int internalValue )
    {
        this.InternalValue = internalValue;
    }
}

public class MyEnum : MyBaseEnum
{
    public static readonly MyEnum D = new MyEnum( 4 );
    public static readonly MyEnum E = new MyEnum( 5 );

    protected MyEnum( int internalValue ) : base( internalValue )
    {
        // Nothing
    }
}

[TestMethod]
public void EnumTest()
{
    this.DoSomethingMeaningful( MyEnum.A );
}

private void DoSomethingMeaningful( MyBaseEnum enumValue )
{
    // ...
    if( enumValue == MyEnum.A ) { /* ... */ }
    else if (enumValue == MyEnum.B) { /* ... */ }
    // ...
}

根据你的情况，你可能不需要派生enum，因为它们基于System.Enum。

使用这段代码，你可以传入任何你喜欢的Enum，并获得它所选的值:

public CommonError FromErrorCode(Enum code)
{
    Code = (int)Enum.Parse(code.GetType(), code.ToString());

简短的回答是否定的。如果你想，你可以玩一点:

你可以这样做:

private enum Base
{
    A,
    B,
    C
}

private enum Consume
{
    A = Base.A,
    B = Base.B,
    C = Base.C,
    D,
    E
}

但是，它并没有那么好，因为Base。A !=消费。一个

不过，你总是可以这样做:

public static class Extensions
{
    public static T As<T>(this Consume c) where T : struct
    {
        return (T)System.Enum.Parse(typeof(T), c.ToString(), false);
    }
}

为了在基础和消费之间交叉…

你也可以将枚举的值转换为整数，并将它们比较为整数而不是enum，但这也很糟糕。

扩展方法return应该将其类型转换为T类型。