ネストされた列挙型を宣言するにはどうすればよいですか？
ネストされた列挙型を次のように宣言したい：
\\pseudocode
public enum Animal
{
dog = 0,
cat = 1
}
private enum dog
{
bulldog = 0,
greyhound = 1,
husky = 3
}
private enum cat
{
persian = 0,
siamese = 1,
burmese = 2
}
Animal patient1 = Animal.dog.husky;
できますか？
ロギングシステム用の軽量で階層的なチャネルIDを作成する方法と似たものを探していました。これが努力に見合う価値があるかどうかはよくわかりませんが、一緒に組み立てるのは楽しいもので、その過程でオペレーターの過負荷とトカゲについて何か新しいことを学びました。
この表記をサポートするメカニズムを構築しました。
public static class Animal
{
public static readonly ID dog = 1;
public static class dogs
{
public static readonly ID bulldog = dog[0];
public static readonly ID greyhound = dog[1];
public static readonly ID husky = dog[3];
}
public static readonly ID cat = 2;
public static class cats
{
public static readonly ID persian = cat[0];
public static readonly ID siamese = cat[1];
public static readonly ID burmese = cat[2];
}
public static readonly ID reptile = 3;
public static class reptiles
{
public static readonly ID snake = reptile[0];
public static class snakes
{
public static readonly ID adder = snake[0];
public static readonly ID boa = snake[1];
public static readonly ID Cobra = snake[2];
}
public static readonly ID lizard = reptile[1];
public static class lizards
{
public static readonly ID gecko = lizard[0];
public static readonly ID komodo = lizard[1];
public static readonly ID iguana = lizard[2];
public static readonly ID chameleon = lizard[3];
}
}
}
そして、あなたはそのように使うことができます：
void Animalize()
{
ID rover = Animal.dogs.bulldog;
ID rhoda = Animal.dogs.greyhound;
ID rafter = Animal.dogs.greyhound;
ID felix = Animal.cats.persian;
ID zorro = Animal.cats.burmese;
ID rango = Animal.reptiles.lizards.chameleon;
if (rover.isa(Animal.dog))
Console.WriteLine("rover is a dog");
else
Console.WriteLine("rover is not a dog?!");
if (rover == rhoda)
Console.WriteLine("rover and rhoda are the same");
if (rover.super == rhoda.super)
Console.WriteLine("rover and rhoda are related");
if (rhoda == rafter)
Console.WriteLine("rhoda and rafter are the same");
if (felix.isa(zorro))
Console.WriteLine("er, wut?");
if (rango.isa(Animal.reptile))
Console.WriteLine("rango is a reptile");
Console.WriteLine("rango is an {0}", rango.ToString<Animal>());
}
そのコードがコンパイルされ、次の出力が生成されます。
rover is a dog
rover and rhoda are related
rhoda and rafter are the same
rango is a reptile
rango is an Animal.reptiles.lizards.chameleon
これを機能させるID構造体は次のとおりです。
public struct ID
{
public static ID none;
public ID this[int childID]
{
get { return new ID((mID << 8) | (uint)childID); }
}
public ID super
{
get { return new ID(mID >> 8); }
}
public bool isa(ID super)
{
return (this != none) && ((this.super == super) || this.super.isa(super));
}
public static implicit operator ID(int id)
{
if (id == 0)
{
throw new System.InvalidCastException("top level id cannot be 0");
}
return new ID((uint)id);
}
public static bool operator ==(ID a, ID b)
{
return a.mID == b.mID;
}
public static bool operator !=(ID a, ID b)
{
return a.mID != b.mID;
}
public override bool Equals(object obj)
{
if (obj is ID)
return ((ID)obj).mID == mID;
else
return false;
}
public override int GetHashCode()
{
return (int)mID;
}
private ID(uint id)
{
mID = id;
}
private readonly uint mID;
}
これは以下を利用します：
- 基本型としての32ビットuint
- ビットシフトで整数に詰められた複数の小さな数値（各レベルで256エントリを持つネストされたIDの最大4レベルを取得します-より多くのレベルまたはレベルごとのより多くのビットのためにulongに変換できます）
- すべてのIDの特別なルートとしてのID 0（おそらくID.noneはID.rootと呼ばれ、id.isa（ID.root）はすべてtrueである必要があります）
- 暗黙の型変換 intをIDに変換する
- indexer はIDを一緒にチェーンします
- オーバーロードされた等価演算子 比較をサポートします
これまでのところ、すべてがかなり効率的ですが、ToStringのリフレクションと再帰に頼らざるを得なかったため、次のように extension method でコードをまとめました。
using System;
using System.Reflection;
public static class IDExtensions
{
public static string ToString<T>(this ID id)
{
return ToString(id, typeof(T));
}
public static string ToString(this ID id, Type type)
{
foreach (var field in type.GetFields(BindingFlags.GetField | BindingFlags.Public | BindingFlags.Static))
{
if ((field.FieldType == typeof(ID)) && id.Equals(field.GetValue(null)))
{
return string.Format("{0}.{1}", type.ToString().Replace('+', '.'), field.Name);
}
}
foreach (var nestedType in type.GetNestedTypes())
{
string asNestedType = ToString(id, nestedType);
if (asNestedType != null)
{
return asNestedType;
}
}
return null;
}
}
これが機能するためには、 静的クラスは型パラメーターとして使用できない なので、Animalは静的クラスではなくなる可能性があるため、代わりにプライベートコンストラクターでシールしたことに注意してください。
public /*static*/ sealed class Animal
{
// Or else: error CS0718: 'Animal': static types cannot be used as type arguments
private Animal()
{
}
....
ふew！読んでくれてありがとう。 :-)
これを実現するには、列挙ビットフィールドと拡張メソッドを組み合わせて使用することになるでしょう。例えば：
public enum Animal
{
None = 0x00000000,
AnimalTypeMask = 0xFFFF0000,
Dog = 0x00010000,
Cat = 0x00020000,
Alsation = Dog | 0x00000001,
Greyhound = Dog | 0x00000002,
Siamese = Cat | 0x00000001
}
public static class AnimalExtensions
{
public bool IsAKindOf(this Animal animal, Animal type)
{
return (((int)animal) & AnimalTypeMask) == (int)type);
}
}
更新
。NET 4では、Enum.HasFlagメソッドではなく、独自の拡張機能をロールします。
このメソッドを使用して、必要なものを取得できます。
public static class Animal {
public enum Dog {
BullDog,
GreyHound,
Huskey
}
public enum Cat {
Tabby,
Bombbay
}
}
単に、いいえ、それはできません。
Animal enum内のすべての値を定義することをお勧めします。この特定の構造が必要な理由はありますか？
これは古い質問ですが、最近このようなことが可能かどうか疑問に思いました。 C＃には列挙型の継承のようなものはなく、このようなものを作成する唯一の方法はyoyoの答えのようなカスタムクラスになるでしょう。問題は、それらが実際には列挙型ではなく（たとえば、switchステートメントで使用できない）、ネストされたコードの性質により、すばやく読んで理解するのが難しいことです。
同様の動作を得る最も簡単な方法は、単一のフラットな列挙型を使用して、関係を含む属性（継承）で列挙型を装飾することであることがわかりました。これにより、コードが読みやすくなり、理解しやすくなります。
class AnimalAttribute : Attribute {}
class DogAttribute : AnimalAttribute {}
class CatAttribute : AnimalAttribute {}
class ReptileAttribute : AnimalAttribute {}
class SnakeAttribute : ReptileAttribute {}
class LizardAttribute : ReptileAttribute {}
enum Animal
{
[Dog] bulldog,
[Dog] greyhound,
[Dog] husky,
[Cat] persian,
[Cat] siamese,
[Cat] burmese,
[Snake] adder,
[Snake] boa,
[Snake] Cobra,
[Lizard] gecko,
[Lizard] komodo,
[Lizard] iguana,
[Lizard] chameleon
}
これで、列挙型は通常の列挙型と同じように使用でき、いくつかの単純な拡張メソッドでそれらの関係を調べることができます。
static class Animals
{
public static Type AnimalType(this Enum value )
{
var member = value.GetType().GetMember(value.ToString()).FirstOrDefault();
// this assumes a single animal attribute
return member == null ? null :
member.GetCustomAttributes()
.Where(at => at is AnimalAttribute)
.Cast<AnimalAttribute>().FirstOrDefault().GetType();
}
public static bool IsCat(this Enum value) { return value.HasAttribute<CatAttribute>(); }
public static bool IsDog(this Enum value) { return value.HasAttribute<DogAttribute>(); }
public static bool IsAnimal(this Enum value) { return value.HasAttribute<AnimalAttribute>(); }
public static bool IsReptile(this Enum value) { return value.HasAttribute<ReptileAttribute>(); }
public static bool IsSnake(this Enum value) { return value.HasAttribute<SnakeAttribute>(); }
public static bool IsLizard(this Enum value) { return value.HasAttribute<LizardAttribute>(); }
public static bool HasAttribute<T>(this Enum value)
{
var member = value.GetType().GetMember(value.ToString()).FirstOrDefault();
return member != null && Attribute.IsDefined(member, typeof(T));
}
public static string ToString<T>(this Animal value) where T : AnimalAttribute
{
var type = value.AnimalType();
var s = "";
while( type != null && !(type == typeof(Object)) )
{
s = type.Name.Replace("Attribute","") + "."+s;
type = type.BaseType;
}
return s.Trim('.');
}
}
Yoyosと同様のテスト：
void Main()
{
Animal rover = Animal.bulldog;
Animal rhoda = Animal.greyhound;
Animal rafter = Animal.greyhound;
Animal felix = Animal.persian;
Animal zorrow = Animal.burmese;
Animal rango = Animal.chameleon;
if( rover.IsDog() )
Console.WriteLine("rover is a dog");
else
Console.WriteLine("rover is not a dog?!");
if( rover == rhoda )
Console.WriteLine("rover and rhonda are the same type");
if( rover.AnimalType() == rhoda.AnimalType() )
Console.WriteLine("rover and rhonda are related");
if( rhoda == rafter )
Console.WriteLine("rhonda and rafter are the same type");
if( rango.IsReptile() )
Console.WriteLine("rango is a reptile");
Console.WriteLine(rover.ToString<AnimalAttribute>());
}
唯一欠けているのは、ネストされたクラスのドットアクセス構文ですが、パフォーマンスが重要なコードを記述していない場合は、ダイナミクスで同様のことを実現できます。
public static dynamic dogs
{
get {
var eo = new ExpandoObject() as IDictionary<string,object>;
foreach( var value in Enum.GetValues(typeof(Animal)).Cast<Animal>().Where(a => a.IsDog()))
eo[value.ToString()] = value;
return eo;
}
}
public static dynamic cats
{
get {
var eo = new ExpandoObject() as IDictionary<string,object>;
foreach( var value in Enum.GetValues(typeof(Animal)).Cast<Animal>().Where(a => a.IsCat()))
eo[value.ToString()] = value;
return eo;
}
}
このような拡張メソッドを追加すると、特定の属性を持つ列挙型にアクセスできるため、変数を次のように設定できます。
Animal rhoda = Animals.dogs.greyhound;
Animal felix = Animals.cats.persian;
私はそれがそのように機能するとは思わない。
列挙型は、単純な並列値のセットであると想定されています。
あなたは継承との関係を表現したいと思うかもしれません。
public class Animal
{
public Animal(string name = "")
{
Name = name;
Perform = Performs.Nothing;
}
public enum Performs
{
Nothing,
Sleep,
Eat,
Dring,
Moan,
Flee,
Search,
WhatEver
}
public string Name { get; set; }
public Performs Perform { get; set; }
}
public class Cat : Animal
{
public Cat(Types type, string name)
: base (name)
{
Type = type;
}
public enum Types
{
Siamese,
Bengal,
Bombay,
WhatEver
}
public Types Type { get; private set; }
}
public class Dog : Animal
{
public Dog(Types type, string name)
: base(name)
{
Type = type;
}
public enum Types
{
Greyhound,
Alsation,
WhatEver
}
public Types Type { get; private set; }
}
次の質問をご覧ください。
リフレクションを使用したタイプの静的フィールド値の取得
Enumと同じ方法で文字列値を定数として格納
質問は基本的な文字列列挙の構築をカバーしていますが、この状況で役立つかもしれないICustomEnum<T>インターフェイスを使用して私の回答を実装します。
public enum Animal
{
CAT_type1= AnimalGroup.CAT,
CAT_type2 = AnimalGroup.CAT,
DOG_type1 = AnimalGroup.DOG,
}
public enum AnimalGroup
{
CAT,
DOG
}
public static class AnimalExtensions
{
public static bool isGroup(this Animal animal,AnimalGroup groupNumber)
{
if ((AnimalGroup)animal == groupNumber)
return true;
return false;
}
}
これは私の解決策/回避策です：
public static class Categories
{
public const string Outlink = "Outlink";
public const string Login = "Login";
}
public enum Action
{
/// <summary>
/// Outlink is a anchor tag pointing to an external Host
/// </summary>
[Action(Categories.Outlink, "Click")]
OutlinkClick,
[Action(Categories.Outlink, "ClickBlocked")]
OutlinkClickBlocked,
/// <summary>
/// User account events
/// </summary>
[Action(Categories.Login, "Succeeded")]
LoginSucceeded,
[Action(Categories.Login, "Failed")]
LoginFailed
}
public class ActionAttribute : Attribute
{
public string Category { get; private set; }
public string Action { get; private set; }
public ActionAttribute(string category, string action)
{
Category = category;
Action = action;
}
}
おそらくこれで十分でしょうか？
class A
{
public const int Foo = 0;
public const int Bar = 1;
}
class B : A
{
public const int Baz = 2;
}