我在低级命名空间中有一个枚举。我想在“继承”低级枚举的中级命名空间中提供一个类或枚举。
namespace low
{
public enum base
{
x, y, z
}
}
namespace mid
{
public enum consume : low.base
{
}
}
我希望这是可能的，或者可能是某种可以代替枚举消耗的类，它将为枚举提供一个抽象层，但仍然让该类的实例访问枚举。
想法？
编辑： 我不只是在类中将其切换为 consts 的原因之一是我必须使用的服务需要低级枚举。我得到了 WSDL 和 XSD，它们将结构定义为枚举。服务无法更改。
【问题讨论】：
这是不可能的。枚举不能从其他枚举继承。事实上，所有枚举实际上都必须继承自 System.Enum。 C# 允许语法改变枚举值的底层表示，看起来像继承，但实际上它们仍然继承自 System.enum。
有关详细信息，请参阅CLI spec 的第 8.5.2 节。规范中的相关信息
System.Enum
【讨论】：
switch 情况下使用。
你可以通过类实现你想要的：
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;
【讨论】：
Enum.GetValues(typeof(MyEnum)
void Test() { foreach (System.Reflection.PropertyInfo pi in typeof(Consume).GetProperties()) { Console.WriteLine(pi.Name); } }
简短的回答是否定的。如果你愿意，你可以玩一下：
你总是可以这样做：
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);
}
}
为了在 Base 和 Consume 之间进行交叉...
您也可以将枚举的值转换为整数，并将它们作为整数而不是枚举进行比较，但这也很糟糕。
扩展方法返回应该类型转换为 T。
【讨论】：
Base.A == (Base)Consume.A
int 会更有意义。枚举什么时候会有小数部分！？！？！
上述使用具有 int 常量的类的解决方案缺乏类型安全性。 IE。您可以发明实际上未在类中定义的新值。 此外，不可能编写一个将这些类之一作为输入的方法。
你需要写
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) { /* ... */ }
// ...
}
【讨论】：
object's 会使程序集的每个实例化的值不同，因此它们不能被序列化。
忽略 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)
{
}
【讨论】：
DogType 和 AnimalType 是否有理由从 BaseAnimal 继承？根据我所看到的，这些可以制成静态类
这就是我所做的。我所做的不同是在“消费”enum 上使用相同的名称和new 关键字。因为enum的名字是一样的，随便用就行了。另外，您可以获得智能感知。您只需在设置时手动注意从基础复制值并使其保持同步。您可以与代码 cmets 一起提供帮助。这是在数据库中存储enum 值时我总是存储字符串而不是值的另一个原因。因为如果您使用自动分配的递增整数值，这些值可能会随着时间而改变。
// Base Class for balls
public class Ball
{
// keep synced with subclasses!
public enum Sizes
{
Small,
Medium,
Large
}
}
public class VolleyBall : Ball
{
// keep synced with base class!
public new enum Sizes
{
Small = Ball.Sizes.Small,
Medium = Ball.Sizes.Medium,
Large = Ball.Sizes.Large,
SmallMedium,
MediumLarge,
Ginormous
}
}
【讨论】：
SmallMedium = 100,），以便在基类中添加新值时可以保持与旧版本软件的兼容性。例如，在基本枚举中添加Huge 大小会将4 分配给它的值，但4 已经被派生类中的SmallMedium 采用。
Huge 需要在SmallMedium 之前的子类中添加Huge
在我的公司，我们避免“跳过项目”来处理不常见的较低级别的项目。比如我们的表现层/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()
{}
}
这具有三个真正的优势......
要引用第一个项目中的枚举，可以使用类的前缀：BaseEnums.StatusType.Pending或添加一个“使用静态BaseEnums ;" 声明你的使用。
在第二个项目中处理继承类时，我无法让“使用静态...”方法工作，所以所有对“继承的枚举”将以类为前缀，例如SubEnums.StatusType.Pending。如果有人想出一种方法来允许在第二个项目中使用 “使用静态” 方法，请告诉我。
我确信可以对此进行调整以使其变得更好 - 但这确实有效，并且我在工作项目中使用了这种方法。
【讨论】：
我还想重载 Enums，并创建了 the answer of 'Seven' on this page 和 the answer of 'Merlyn Morgan-Graham' on a duplicate post of this 的组合，以及一些改进。
我的解决方案与其他解决方案相比的主要优势：
这是一个开箱即用的解决方案，可以直接插入到您的项目中。它是根据我的需要设计的，所以如果你不喜欢它的某些部分，只需用你自己的代码替换它们。
首先，所有自定义枚举都应继承自基类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
}
【讨论】：
我意识到我参加这个聚会有点晚了，但这是我的两分钱。
我们都清楚框架不支持枚举继承。在这个帖子中提出了一些非常有趣的解决方法，但它们都不像我正在寻找的那样，所以我自己尝试了一下。
介绍：ObjectEnum
您可以在此处查看代码和文档：https://github.com/dimi3tron/ObjectEnum。
还有这里的包裹：https://www.nuget.org/packages/ObjectEnum
或者直接安装：Install-Package ObjectEnum
简而言之，ObjectEnum<TEnum> 充当任何枚举的包装器。通过覆盖子类中的 GetDefinedValues()，可以指定哪些枚举值对这个特定的类有效。
添加了许多运算符重载以使 ObjectEnum<TEnum> 实例的行为就像它是底层枚举的实例一样，请记住定义的值限制。这意味着您可以轻松地将实例与 int 或 enum 值进行比较，从而在 switch case 或任何其他条件下使用它。
我想参考上面提到的 github 存储库以获取示例和更多信息。
我希望你觉得这很有用。欢迎在 github 上发表评论或打开问题，以获取更多想法或 cmets。
这里有几个简短的例子来说明你可以用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;
}
【讨论】：
枚举不是实际的类，即使它们看起来很像。在内部，它们的处理方式与它们的基础类型一样（默认为 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
HTH
【讨论】：
这是不可能的（正如@JaredPar 已经提到的）。试图用逻辑来解决这个问题是一种不好的做法。如果你有一个base class 和一个enum，你应该在那里列出所有可能的enum-values，并且类的实现应该使用它知道的值。
例如假设你有一个基类BaseCatalog，它有一个enum ProductFormats（Digital，Physical）。然后你可以有一个MusicCatalog 或BookCatalog 可以包含Digital 和Physical 产品，但如果类是ClothingCatalog，它应该只包含Physical 产品。
【讨论】：
您可以在枚举中执行继承，但仅限于以下类型。 int, uint, byte, sbyte, short, ushort, long, ulong
例如
public enum Car:int{
Toyota,
Benz,
}
【讨论】：