Enum Inheritance

Question

I have an enum in a low level namespace  I d like to provide a class or enum in a mid level namespace that  inherits  the low level enum   namespace low      public enum base            x  y  z         namespace mid      public enum consume   low base               I m hoping that this is possible  or perhaps some kind of class that can take the place of the enum consume which will provide a layer of abstraction for the enum  but still let an instance of that class access the enum   Thoughts   EDIT  One of the reasons I haven t just switched this to consts in classes is that the low level enum is needed by a service that I must consume  I have been given the WSDLs and the XSDs  which define the structure as an enum  The service cannot be changed

User · Answer

another possible solution   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

User · Answer

You can perform inheritance in enum  however it s limited to following types only    int  uint  byte  sbyte  short  ushort  long  ulong   E g   public enum Car int  Toyota  Benz

User · Answer

Enums cannot be derrived from other enums  but only from int  uint  short  ushort  long  ulong  byte and sbyte    Like Pascal said  you can use other enum s values or constants to initialize an enum value  but that s about it

User · Answer

Ignoring the fact that base is a reserved word you cannot do inheritance of enum   The best thing you could do is something like that   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              Since they re all the same base type  ie  int  you could assign the value from an instance of one type to the other which a cast  Not ideal but it work

User · Answer

I know this answer is kind of late but this is what I ended up doing   public class BaseAnimal   IEquatable lt BaseAnimal gt        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  amp  amp  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             Then I am able to do things like   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

User · Answer

I also wanted to overload Enums and created a mix of the answer of  Seven  on this page and the answer of  Merlyn Morgan-Graham  on a duplicate post of this  plus a couple of improvements  Main advantages of my solution over the others      automatic increment of the underlying int value automatic naming   This is an out-of-the-box solution and may be directly inserted into your project  It is designed to my needs  so if you don t like some parts of it  just replace them with your own code   First  there is the base class CEnum that all custom enums should inherit from  It has the basic functionality  similar to the  net Enum type   public class CEnum     protected static readonly int msc iUpdateNames    int MinValue    protected static int          ms iAutoValue       -1    protected static List lt int gt     ms listiValue       new List lt int gt        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 lt CEnum gt  i listoValue          if  i listoValue    null        return null      string   asName   new string i listoValue Count       for  int ixCnt   0  ixCnt  lt  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  gt  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                Secondly  here are 2 derived Enum classes  All derived classes need some basic methods in order to work as expected  It s always the same boilerplate code  I haven t found a way yet to outsource it to the base class  The code of the first level of inheritance differs slightly from all subsequent levels    public class CEnumResult   CEnum     private   static List lt CEnumResult gt   ms listoValue   new List lt CEnumResult gt        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 lt CEnumResult gt  listoValue   new List lt CEnumResult gt          listoValue AddRange  ms listoValue       return listoValue ToArray            public class CEnumResultClassCommon   CEnumResult     private   static List lt CEnumResultClassCommon gt  ms listoValue   new List lt CEnumResultClassCommon gt        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 lt CEnumResult gt  listoValue   new List lt CEnumResult gt   CEnumResult GetValues          listoValue AddRange  ms listoValue       return listoValue ToArray             The classes have been successfully tested with follwing code     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

User · Answer

The solutions above using classes with int constants lack type-safety  I e  you could invent new values actually not defined in the class  Furthermore it is not possible for example to write a method taking one of these classes as input   You would need to write  public void DoSomethingMeaningFull int consumeValue        However  there is a class based solution of the old days of Java  when there were no enums available  This provides an almost enum-like behaviour  The only caveat is that these constants cannot be used within a switch-statement   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

User · Answer

Alternative solution In my company  we avoid  quot jumping over projects quot  to get to non-common lower level projects  For instance  our presentation API layer can only reference our domain layer  and the domain layer can only reference the data layer  However  this is a problem when there are enums that need to be referenced by both the presentation and the domain layers  Here is the solution that we have implemented  so far   It is a pretty good solution and works well for us  The other answers were hitting all around this  The basic premise is that enums cannot be inherited - but classes can  So       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        Then  to  quot inherit quot  the enums in another higher level project       Class in another project public sealed class SubEnums  BaseEnums      private SubEnums            This has three real advantages     The enum definitions are automatically the same in both projects - by definition  Any changes to the enum definitions are automatically echoed in the second without having to make any modifications to the second class  The enums are based on the same code - so the values can easily be compared  with some caveats    To reference the enums in the first project  you can use the prefix of the class  BaseEnums StatusType Pending or add a  quot using static BaseEnums  quot  statement to your usings  In the second project when dealing with the inherited class however  I could not get the  quot using static     quot  approach to work  so all references to the  quot inherited enums quot  would be prefixed with the class  e g  SubEnums StatusType Pending  If anyone comes up with a way to allow the  quot using static quot  approach to be used in the second project  let me know  I am sure that this can be tweaked to make it even better - but this actually works and I have used this approach in working projects  Please up-vote this if you find it helpful

User · Answer

Enums are not actual classes  even if they look like it  Internally  they are treated just like their underlying type  by default Int32   Therefore  you can only do this by  copying  single values from one enum to another and casting them to their integer number to compare them for equality

User · Answer

The short answer is no   You can play a bit  if you want   You can always do something like this   private enum Base       A      B      C    private enum Consume       A   Base A      B   Base B      C   Base C      D      E     But  it doesn t work all that great because Base A    Consume A  You can always do something like this  though   public static class Extensions       public static T As lt T gt  this Consume c  where T   struct               return  T System Enum Parse typeof T   c ToString    false             In order to cross between Base and Consume      You could also cast the values of the enums as ints  and compare them as ints instead of enum  but that kind of sucks too   The extension method return should type cast it type T

User · Answer

This is not possible  as  JaredPar already mentioned   Trying to put logic to work around this is a bad practice  In case you have a base class that have an enum  you should list of all possible enum-values there  and the implementation of class should work with the values that it knows   E g  Supposed you have a base class BaseCatalog  and it has an enum ProductFormats  Digital  Physical   Then you can have a MusicCatalog or BookCatalog that could contains both Digital and Physical products  But if the class is ClothingCatalog  it should only contains Physical products

User · Answer

This is not possible   Enums cannot inherit from other enums  In fact all enums must actually inherit from System Enum   C  allows syntax to change the underlying representation of the enum values which looks like inheritance  but in actuality they still inherit from System enum   See section 8 5 2 of the CLI spec for the full details   Relevant information from the spec   All enums must derive from System Enum Because of the above  all enums are value types and hence sealed

User · Answer

This is what I did  What I ve done differently is use the same name and the new keyword on the  consuming  enum  Since the name of the enum is the same  you can just mindlessly use it and it will be right  Plus you get intellisense  You just have to manually take care when setting it up that the values are copied over from the base and keep them sync ed  You can help that along with code comments  This is another reason why in the database when storing enum values I always store the string  not the value  Because if you are using automatically assigned increasing integer values those can change over time      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

User · Answer

You can achieve what you want with classes   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      Now you can use these classes similar as when they were enums   int i   Consume B    Update  after your update of the question    If you assign the same int values to the constants as defined in the existing enum  then you can cast between the enum and the constants  e g   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

User · Answer

I realize I m a bit late to this party  but here s my two cents  We re all clear that Enum inheritance is not supported by the framework  Some very interesting workarounds have been suggested in this thread  but none of them felt quite like what I was looking for  so I had a go at it myself  Introducing  ObjectEnum You can check the code and documentation here  https   github com dimi3tron ObjectEnum  And the package here  https   www nuget org packages ObjectEnum Or just install it  Install-Package ObjectEnum In short  ObjectEnum lt TEnum gt  acts as a wrapper for any enum  By overriding the GetDefinedValues   in subclasses  one can specify which enum values are valid for this specific class  A number of operator overloads have been added to make an ObjectEnum lt TEnum gt  instance behave as if it were an instance of the underlying enum  keeping in mind the defined value restrictions  This means you can easily compare the instance to an int or enum value  and thus use it in a switch case or any other conditional  I d like to refer to the github repo mentioned above for examples and further info  I hope you find this useful  Feel free to comment or open an issue on github for further thoughts or comments  Here are a few short examples of what you can do with ObjectEnum lt TEnum gt   var sunday   new WorkDay DayOfWeek Sunday     throws exception var monday   new WorkDay DayOfWeek Monday     works fine var label     quot  monday  is day   int monday   quot    produces   quot Monday is day 1  quot  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

[c#] Enum "Inheritance"

Examples related to c#

Examples related to .net

Examples related to enums