我在低级名称空间中有一个枚举。我想在“继承”低级枚举的中级命名空间中提供一个类或枚举。

namespace low
{
   public enum base
   {
      x, y, z
   }
}

namespace mid
{
   public enum consume : low.base
   {
   }
}

我希望这是可能的，或者希望可以使用某种类来代替枚举消耗，这将为枚举提供抽象层，但仍允许该类的实例访问枚举。

有什么想法吗？

编辑：我没有将其转换为类中的const的原因之一是我必须使用的服务需要低级枚举。我得到了WSDL和XSD，它们将结构定义为枚举。该服务无法更改。

这不可能。枚举不能从其他枚举继承。实际上，所有枚举实际上都必须继承自System.Enum。C＃允许使用语法更改看起来像继承的枚举值的基本表示形式，但实际上它们仍然继承自System.enum。

有关完整详细信息，请参见CLI规范的 8.5.2节。规范中的相关信息

• 所有枚举必须源自 System.Enum
• 由于上述原因，所有枚举都是值类型，因此是密封的

您可以通过类实现您想要的：

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;

最简洁的答案是不。如果需要，您可以玩一些：

您始终可以执行以下操作：

private enum Base
{
    A,
    B,
    C
}

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

但是，由于Base.A！= Consume.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);
    }
}

为了跨越基础和消费...

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

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

上面使用具有int常量的类的解决方案缺乏类型安全性。即，您可以发明实际上在类中未定义的新值。此外，例如不可能编写将这些类之一作为输入的方法。

你需要写

public void DoSomethingMeaningFull(int consumeValue) ...

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

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) { /* ... */ }
    // ...
}

忽略base是保留字的事实，您不能继承枚举。

您能做的最好的事情是这样的：

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 BaseAnimal : IEquatable<BaseAnimal>
{
    public string Name { private set; get; }
    public int Value { private set; get; }

    public BaseAnimal(int value, String name)
    {
        this.Name = name;
        this.Value = value;
    }

    public override String ToString()
    {
        return Name;
    }

    public bool Equals(BaseAnimal other)
    {
        return other.Name == this.Name && other.Value == this.Value;
    }
}

public class AnimalType : BaseAnimal
{
    public static readonly BaseAnimal Invertebrate = new BaseAnimal(1, "Invertebrate");

    public static readonly BaseAnimal Amphibians = new BaseAnimal(2, "Amphibians");

    // etc        
}

public class DogType : AnimalType
{
    public static readonly BaseAnimal Golden_Retriever = new BaseAnimal(3, "Golden_Retriever");

    public static readonly BaseAnimal Great_Dane = new BaseAnimal(4, "Great_Dane");

    // etc        
}

然后，我可以执行以下操作：

public void SomeMethod()
{
    var a = AnimalType.Amphibians;
    var b = AnimalType.Amphibians;

    if (a == b)
    {
        // should be equal
    }

    // call method as
    Foo(a);

    // using ifs
    if (a == AnimalType.Amphibians)
    {
    }
    else if (a == AnimalType.Invertebrate)
    {
    }
    else if (a == DogType.Golden_Retriever)
    {
    }
    // etc          
}

public void Foo(BaseAnimal typeOfAnimal)
{
}

这就是我所做的。我做的不同的是new在“ consumption”上使用相同的名称和关键字enum。由于的名称enum相同，因此您可以轻而易举地使用它，它将是正确的。另外，您还将获得智能感知。您只需在设置时手动小心，将值从基础复制过来并保持同步即可。您可以在代码注释中提供帮助。这是为什么在数据库中存储enum值时，我总是存储字符串而不是值的另一个原因。因为如果您使用的是自动分配的递增整数值，则这些整数值会随着时间变化。

// Base Class for balls 
public class BaseBall
{
    // keep synced with subclasses!
    public enum Sizes
    {
        Small,
        Medium,
        Large
    }
}

public class VolleyBall : BaseBall
{
    // keep synced with base class!
    public new enum Sizes
    {
        Small = BaseBall.Sizes.Small,
        Medium = BaseBall.Sizes.Medium,
        Large = BaseBall.Sizes.Large,
        SmallMedium,
        MediumLarge,
        Ginormous
    }
}

替代解决方案

在我的公司中，我们避免“跳过项目”进入非常见的较低级别的项目。例如，我们的表示/ API层只能引用我们的域层，而域层只能引用数据层。

但是，当存在表示层和域层都需要引用的枚举时，这是一个问题。

这是到目前为止我们已经实现的解决方案。这是一个很好的解决方案，对我们来说效果很好。其他答案都围绕着这个问题。

基本前提是枚举不能被继承-但类可以被继承。所以...

// In the lower level project (or DLL)...
public abstract class BaseEnums
{
    public enum ImportanceType
    {
        None = 0,
        Success = 1,
        Warning = 2,
        Information = 3,
        Exclamation = 4
    }

    [Flags]
    public enum StatusType : Int32
    {
        None = 0,
        Pending = 1,
        Approved = 2,
        Canceled = 4,
        Accepted = (8 | Approved),
        Rejected = 16,
        Shipped = (32 | Accepted),
        Reconciled = (64 | Shipped)
    }

    public enum Conveyance
    {
        None = 0,
        Feet = 1,
        Automobile = 2,
        Bicycle = 3,
        Motorcycle = 4,
        TukTuk = 5,
        Horse = 6,
        Yak = 7,
        Segue = 8
    }

然后，“继承”另一个更高级别项目中的枚举。

// Class in another project
public sealed class SubEnums: BaseEnums
{
   private SubEnums()
   {}
}

这具有三个真正的优势...

1. 根据定义，两个项目中的枚举定义自动相同。
2. 对枚举定义的任何更改都会在第二个中自动回显，而无需对第二个类进行任何修改。
3. 枚举基于相同的代码-因此可以轻松地比较这些值（有一些警告）。

要引用第一个项目中的枚举，可以使用该类的前缀：BaseEnums.StatusType.Pending或添加“使用静态BaseEnums;”。声明您的使用。

但是，在第二个项目中，当处理继承的类时，我无法使用“使用静态...”方法，因此所有对“继承的枚举”的引用都将带有该类的前缀，例如SubEnums.StatusType.Pending。如果有人提出允许“使用静态”的方法在第二个项目中使用方法的方法，请告诉我。

我敢肯定，可以对其进行调整以使其变得更好-但这确实有效，并且我在工作项目中使用了这种方法。

如果您认为有帮助，请对其进行投票。

我也想超负荷枚举和创建的混合体“七”这个页面上的答案和“摩根Merlyn -格雷厄姆”对这个重复职位的答案，再加上一对夫妇的改进。
我的解决方案相对于其他解决方案的主要优点：

• 基础int值的自动递增
• 自动命名

这是一个开箱即用的解决方案，可以直接插入您的项目中。它是根据我的需要设计的，因此，如果您不喜欢其中的某些部分，只需将其替换为自己的代码即可。

首先，存在CEnum所有自定义枚举都应继承的基类。它具有基本功能，类似于.net Enum类型：

public class CEnum
{
  protected static readonly int msc_iUpdateNames  = int.MinValue;
  protected static int          ms_iAutoValue     = -1;
  protected static List<int>    ms_listiValue     = new List<int>();

  public int Value
  {
    get;
    protected set;
  }

  public string Name
  {
    get;
    protected set;
  }

  protected CEnum ()
  {
    CommonConstructor (-1);
  }

  protected CEnum (int i_iValue)
  {
    CommonConstructor (i_iValue);
  }

  public static string[] GetNames (IList<CEnum> i_listoValue)
  {
    if (i_listoValue == null)
      return null;
    string[] asName = new string[i_listoValue.Count];
    for (int ixCnt = 0; ixCnt < asName.Length; ixCnt++)
      asName[ixCnt] = i_listoValue[ixCnt]?.Name;
    return asName;
  }

  public static CEnum[] GetValues ()
  {
    return new CEnum[0];
  }

  protected virtual void CommonConstructor (int i_iValue)
  {
    if (i_iValue == msc_iUpdateNames)
    {
      UpdateNames (this.GetType ());
      return;
    }
    else if (i_iValue > ms_iAutoValue)
      ms_iAutoValue = i_iValue;
    else
      i_iValue = ++ms_iAutoValue;

    if (ms_listiValue.Contains (i_iValue))
      throw new ArgumentException ("duplicate value " + i_iValue.ToString ());
    Value = i_iValue;
    ms_listiValue.Add (i_iValue);
  }

  private static void UpdateNames (Type i_oType)
  {
    if (i_oType == null)
      return;
    FieldInfo[] aoFieldInfo = i_oType.GetFields (BindingFlags.Public | BindingFlags.Static);

    foreach (FieldInfo oFieldInfo in aoFieldInfo)
    {
      CEnum oEnumResult = oFieldInfo.GetValue (null) as CEnum;
      if (oEnumResult == null)
        continue;
      oEnumResult.Name = oFieldInfo.Name;
    }
  }
}

其次，这是2个派生的Enum类。所有派生类都需要一些基本方法才能按预期工作。总是相同的样板代码；我还没有找到将其外包给基类的方法。继承的第一级代码与所有后续级别略有不同。

public class CEnumResult : CEnum
{
  private   static List<CEnumResult>  ms_listoValue = new List<CEnumResult>();

  public    static readonly CEnumResult Nothing         = new CEnumResult (  0);
  public    static readonly CEnumResult SUCCESS         = new CEnumResult (  1);
  public    static readonly CEnumResult UserAbort       = new CEnumResult ( 11);
  public    static readonly CEnumResult InProgress      = new CEnumResult (101);
  public    static readonly CEnumResult Pausing         = new CEnumResult (201);
  private   static readonly CEnumResult Dummy           = new CEnumResult (msc_iUpdateNames);

  protected CEnumResult () : base ()
  {
  }

  protected CEnumResult (int i_iValue) : base (i_iValue)
  {
  }

  protected override void CommonConstructor (int i_iValue)
  {
    base.CommonConstructor (i_iValue);

    if (i_iValue == msc_iUpdateNames)
      return;
    if (this.GetType () == System.Reflection.MethodBase.GetCurrentMethod ().DeclaringType)
      ms_listoValue.Add (this);
  }

  public static new CEnumResult[] GetValues ()
  {
    List<CEnumResult> listoValue = new List<CEnumResult> ();
    listoValue.AddRange (ms_listoValue);
    return listoValue.ToArray ();
  }
}

public class CEnumResultClassCommon : CEnumResult
{
  private   static List<CEnumResultClassCommon> ms_listoValue = new List<CEnumResultClassCommon>();

  public    static readonly CEnumResult Error_InternalProgramming           = new CEnumResultClassCommon (1000);

  public    static readonly CEnumResult Error_Initialization                = new CEnumResultClassCommon ();
  public    static readonly CEnumResult Error_ObjectNotInitialized          = new CEnumResultClassCommon ();
  public    static readonly CEnumResult Error_DLLMissing                    = new CEnumResultClassCommon ();
  // ... many more
  private   static readonly CEnumResult Dummy                               = new CEnumResultClassCommon (msc_iUpdateNames);

  protected CEnumResultClassCommon () : base ()
  {
  }

  protected CEnumResultClassCommon (int i_iValue) : base (i_iValue)
  {
  }

  protected override void CommonConstructor (int i_iValue)
  {
    base.CommonConstructor (i_iValue);

    if (i_iValue == msc_iUpdateNames)
      return;
    if (this.GetType () == System.Reflection.MethodBase.GetCurrentMethod ().DeclaringType)
      ms_listoValue.Add (this);
  }

  public static new CEnumResult[] GetValues ()
  {
    List<CEnumResult> listoValue = new List<CEnumResult> (CEnumResult.GetValues ());
    listoValue.AddRange (ms_listoValue);
    return listoValue.ToArray ();
  }
}

这些类已成功通过以下代码测试：

private static void Main (string[] args)
{
  CEnumResult oEnumResult = CEnumResultClassCommon.Error_Initialization;
  string sName = oEnumResult.Name;   // sName = "Error_Initialization"

  CEnum[] aoEnumResult = CEnumResultClassCommon.GetValues ();   // aoEnumResult = {testCEnumResult.Program.CEnumResult[9]}
  string[] asEnumNames = CEnum.GetNames (aoEnumResult);
  int ixValue = Array.IndexOf (aoEnumResult, oEnumResult);    // ixValue = 6
}

枚举不是实际的类，即使看起来像这样。在内部，它们就像它们的基础类型一样（默认为Int32）。因此，只能通过将单个值从一个枚举“复制”到另一个枚举并将其强制转换为它们的整数以进行相等比较来做到这一点。

枚举不能从其他枚举派生，而只能从int，uint，short，ushort，long，ulong，byte和sbyte派生。

就像Pascal所说的那样，您可以使用其他枚举的值或常量来初始化枚举值，仅此而已。

另一个可能的解决方案：

public enum @base
{
    x,
    y,
    z
}

public enum consume
{
    x = @base.x,
    y = @base.y,
    z = @base.z,

    a,b,c
}

// TODO: Add a unit-test to check that if @base and consume are aligned

高温超导

这是不可能的（就像已经提到的@JaredPar一样）。试图使逻辑变通解决此问题是一种不好的做法。如果您有一个base class具有的enum，则应列出enum-values该处所有可能的值，并且class的实现应使用其已知的值工作。

例如，假设您有一个基类BaseCatalog，并且它有一个enum ProductFormats（Digital，Physical）。然后，您可以有一个MusicCatalog或BookCatalog可以包含Digital和Physical产品的，但是如果类为ClothingCatalog，则它应仅包含Physical产品。

我知道我参加这个聚会有点晚了，但这是我的两分钱。

我们都很清楚框架不支持Enum继承。在该线程中提出了一些非常有趣的解决方法，但是没有一种感觉完全符合我的期望，因此我自己进行了研究。

简介：ObjectEnum

您可以在此处检查代码和文档：https : //github.com/dimi3tron/ObjectEnum。

包在这里： https //www.nuget.org/packages/ObjectEnum

或者只是安装它： Install-Package ObjectEnum

简而言之， ObjectEnum<TEnum>充当任何枚举的包装。通过覆盖子类中的GetDefinedValues（），可以指定哪些枚举值对该特定类有效。

添加了许多运算符重载以使 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;
}

您可以在枚举中执行继承，但是仅限于以下类型。int，uint，byte，sbyte，short，ushort，long，ulong

例如

public enum Car:int{
Toyota,
Benz,
}