低レベルの名前空間に列挙型があります。低レベルの列挙型を「継承」する中間レベルの名前空間にクラスまたは列挙型を提供したいのですが。

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

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

これが可能であること、またはおそらく、enumの抽象化の層を提供するenumの消費の代わりに、そのクラスのインスタンスにenumへのアクセスを許可するある種のクラスが可能であることを願っています。

考え？

編集：これをクラスのconstに切り替えなかった理由の1つは、低レベルの列挙型が、使用する必要のあるサービスに必要であることです。構造体を列挙型として定義するWSDLとXSDが与えられました。サービスは変更できません。

これは不可能です。列挙型は他の列挙型から継承できません。実際、すべての列挙型は実際にから継承する必要がありSystem.Enumます。C＃では、構文によってenum値の基になる表現を変更できます。これは継承のように見えますが、実際には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);
    }
}

ベースと消費の間を行き来するために...

enumの値をintとしてキャストし、それらをenumではなくintとして比較することもできますが、そのようなこともできます。

拡張メソッドのreturnは、型Tを型キャストする必要があります。

上記のint定数を持つクラスを使用するソリューションには、タイプセーフ性がありません。つまり、クラスで実際に定義されていない新しい値を発明できます。さらに、たとえば、これらのクラスの1つを入力として受け取るメソッドを作成することはできません。

あなたは書く必要があります

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

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「消費」のキーワードを使用することenumです。の名前はenum同じなので、気にせず使うことができ、正しいでしょう。さらに、あなたはインテリセンスを得ます。値をベースからコピーし、同期を保つように設定する場合は、手動で注意する必要があります。あなたはコードコメントと一緒にそれを助けることができます。これは、データベースにenum値を格納するときに、値ではなく常に文字列を格納するもう1つの理由です。自動的に割り当てられた増加する整数値を使用している場合、それらは時間とともに変化する可能性があるためです。

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

これには3つの利点があります...

1. 列挙型の定義は、定義により、両方のプロジェクトで自動的に同じになります。
2. enum定義に対する変更は、2番目のクラスに変更を加えることなく、2番目のクラスに自動的にエコーされます。
3. 列挙型は同じコードに基づいているため、値を簡単に比較できます（いくつかの注意事項があります）。

最初のプロジェクトで列挙型を参照するには、クラスの接頭辞BaseEnums.StatusType.Pending を使用するか、「static BaseEnumsを使用して」を追加します。あなたの使用への声明。

ただし、継承されたクラスを処理する2番目のプロジェクトでは、「静的を使用する...」アプローチを機能させることができなかったため、「継承された列挙型」へのすべての参照には、クラスの接頭辞が付きます。たとえば、SubEnums.StatusType.Pending。誰かが「スタティックの使用」を許可する方法を思いついた場合アプローチを2番目のプロジェクトで使用、私に知らせてください。

私はこれをさらに改善するために微調整できると確信しています-しかし、これは実際に機能し、作業プロジェクトでこのアプローチを使用しました。

参考になれば、投票してください。

私はまた、Enumsをオーバーロードしたいと思っており、このページで「7」の回答と、この投稿の重複する投稿で「Merlyn Morgan-Graham」の回答を組み合わせて作成し、さらにいくつかの改善を加えました。
他のソリューションに対する私のソリューションの主な利点：

• 基になる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）と同じように扱われます。したがって、1つの列挙型から別の列挙型に単一の値を「コピー」し、それらを整数にキャストして等しいかどうかを比較することによってのみ、これを行うことができます。

列挙型は他の列挙型から派生することはできませんが、int、uint、short、ushort、long、ulong、byte、sbyteからのみ派生できます。

Pascalが言ったように、他の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

HTH

これは不可能です（@JaredParについては既に説明しました）。これを回避するロジックを配置しようとするのは悪い習慣です。場合は、あなたは持っているbase class持っていることはenum、あなたが可能なすべてのリストをすべきですenum-valuesあり、そしてクラスの実装は、それが知っている値で動作するはずです。

たとえば、基本クラスがありBaseCatalog、それにenum ProductFormats（Digital、Physical）があるとします。次に、MusicCatalogまたはのBookCatalog両方Digitalを含めることができますまたはPhysical製品をClothingCatalog含めることができますが、クラスがの場合、Physical製品のみを含める必要があります。

私はこのパーティーに少し遅れていることに気づきましたが、これは私の2セントです。

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,
}