У меня есть перечисление в низкоуровневом пространстве имен. Я хотел бы предоставить класс или перечисление в пространстве имен среднего уровня, которое «наследует» перечисление низкого уровня.

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

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

Я надеюсь, что это возможно, или, возможно, какой-то класс, который может заменить потребление перечисления, который обеспечит уровень абстракции для перечисления, но все же позволит экземпляру этого класса получить доступ к перечислению.

Мысли?

РЕДАКТИРОВАТЬ: Одна из причин, по которой я не просто переключил это на conts в классах, заключается в том, что перечисление низкого уровня необходимо для службы, которую я должен потреблять. Мне дали WSDL и XSD, которые определяют структуру как перечисление. Услуга не может быть изменена.

Это невозможно. Перечисления не могут наследоваться от других перечислений. На самом деле все перечисления должны наследоваться от System.Enum. C # позволяет синтаксису изменять базовое представление значений перечисления, которое выглядит как наследование, но в действительности они все еще наследуются от System.enum.

См. Раздел 8.5.2 спецификации CLI для полной информации. Соответствующая информация из спецификации

• Все перечисления должны происходить из 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);
    }
}

Для того, чтобы перейти между Base и Consume ...

Вы также можете привести значения перечислений как целые и сравнивать их как целые, а не как перечисление, но это тоже отстой.

Возвращаемым методом расширения должен быть тип cast типа T.

В приведенных выше решениях с использованием классов с константами 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.

Лучшее, что вы можете сделать, это что-то вроде этого:

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ключевое слово для «потребления» enum. Поскольку имя enumодно и то же, вы можете просто бездумно использовать его, и оно будет правильным. Плюс вы получаете intellisense. При настройке нужно просто позаботиться о том, чтобы значения копировались из базы, и синхронизировать их. Вы можете помочь этому наряду с комментариями кода. Это еще одна причина, почему в базе данных при хранении 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. Определения enum автоматически совпадают в обоих проектах - по определению.
2. Любые изменения в определениях перечислений автоматически отображаются во втором, не внося никаких изменений во второй класс.
3. Перечисления основаны на одном и том же коде - поэтому значения можно легко сравнить (с некоторыми оговорками).

Чтобы ссылаться на перечисления в первом проекте , вы можете использовать префикс класса: BaseEnums.StatusType.Pending или добавить «using static BaseEnums;» Заявление о вашем использовании.

Во втором проекте при работе с унаследованным классом, однако, я не мог заставить работать подход «используя статический ...» , поэтому все ссылки на «унаследованные перечисления» должны иметь префикс с классом, например, SubEnums.StatusType.Pending. , Если кто-нибудь придумает, как использовать «статический» подход во втором проекте, дайте мне знать.

Я уверен, что это можно изменить, чтобы сделать его еще лучше - но на самом деле это работает, и я использовал этот подход в рабочих проектах.

Пожалуйста, проголосуйте, если вы найдете это полезным.

Я также хотел перегрузить Enums и создал комбинацию ответа «Семь» на этой странице и ответа «Мерлин Морган-Грэм» в дублирующем посте , а также пару улучшений.
Основные преимущества моего решения перед другими:

• автоматическое увеличение базового значения int
• автоматическое именование

Это готовое решение, которое может быть вставлено непосредственно в ваш проект. Он разработан для моих нужд, поэтому, если вам не нравятся некоторые его части, просто замените их собственным кодом.

Во-первых, существует базовый класс CEnum, от которого должны наследоваться все пользовательские перечисления. Он имеет базовую функциональность, аналогичную Enumтипу .net :

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.

Как сказал Паскаль, вы можете использовать другие значения или константы enum для инициализации значения enum, но это все.

другое возможное решение:

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варианты, и реализация класса должна работать со значениями, которые он знает.

Например, предположим, что у вас есть базовый класс 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;
}

Вы можете выполнять наследование в enum, однако оно ограничено только следующими типами. int, uint, byte, sbyte, short, ushort, long, ulong

Например

public enum Car:int{
Toyota,
Benz,
}