Wie deklariere ich eine verschachtelte Enumeration?

Question

Ich möchte eine verschachtelte Enum erklären, wie:

\\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; 

es kann getan werden?

Answer 1

Ich war auf der Suche nach etwas ähnliches wie eine Art und Weise leicht, hierarchische Kanal-IDs für ein Logging-System zu erstellen. Ich bin mir nicht ganz sicher, ob das die Mühe wert war, aber ich hatte Spaß dabei, es zusammenzusetzen, und ich lernte etwas Neues über das Überladen von Maschinen und Eidechsen.

Ich habe einen Mechanismus eingebaut, der diese Notation unterstützt:

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]; 
     } 
    } 
} 

Und welche können Sie wie so verwenden:

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>()); 
} 

Dieser Code kompiliert und erzeugt die folgende Ausgabe:

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 

Hier ist die ID-Struktur, die es funktioniert:

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

Dies macht den Einsatz von:

• ein 32-Bit-uint als die zugrunde liegende Typ
• mehrere kleine Zahlen in eine ganze Zahl mit Bit-Verschiebungen gefüllt (Sie maximal vier Ebenen von verschachtelten IDs mit 256 erhalten Einträge auf jeder Ebene - Sie könnten in Ulong für mehr Ebenen oder mehr Bits pro Ebene konvertieren)
• ID 0 als die spezielle Wurzel aller IDs (möglicherweise ID.none sollte ID.root genannt werden, und jede ID.isa (ID.root) sollte wahr sein)
• implicit type conversion einen int in eine ID
• ein indexer Ketten IDs zusammen
• overloaded equality operators unterstützen Vergleiche

Bis jetzt ist alles ziemlich effizient zu konvertieren, aber ich musste Reflexion und Rekursion für ToString zurückgreifen, so ich riegelten es in einem extension method aus wie folgt:

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

Beachten sie, dass für dieses Tier zu arbeiten, konnte nicht mehr eine statische Klasse, weil static classes can't be used as type parameters, so habe ich es versiegelt wit h ein privater Erbauer stattdessen:

public /*static*/ sealed class Animal 
{ 
    // Or else: error CS0718: 'Animal': static types cannot be used as type arguments 
    private Animal() 
    { 
    } 
    .... 

Puh! Danke fürs Lesen. :-)

Answer 2

Einfach, nein, kann es nicht.

Ich empfehle, dass Sie alle Werte innerhalb der Animal enum definieren. Gibt es einen Grund, warum Sie diese besondere Struktur wollen?

Answer 3

Ich glaube nicht, dass es so funktioniert.

Aufzählungen sollen ein einfacher Satz paralleler Werte sein.

Sie möchten diese Beziehung mit der Vererbung ausdrücken.

Answer 4

Sie diese Methode verwenden, können zu bekommen, was Sie

public static class Animal { 
    public enum Dog { 
     BullDog, 
     GreyHound, 
     Huskey 
    } 

    public enum Cat { 
     Tabby, 
     Bombbay 
    } 
} 

Answer 5

Sehen Sie diese Fragen allerdings wollen:
Getting static field values of a type using reflection
Storing string values as constants in the same manner as Enum

Die Fragen decken ein Grund String enum Gebäude, aber ich meine Antworten implementieren Verwenden Sie eine ICustomEnum<T> Schnittstelle, die Ihnen in dieser Situation helfen könnte.

Answer 6

Vielleicht würde das ausreichen?

class A 
{ 
    public const int Foo = 0; 
    public const int Bar = 1; 
} 

class B : A 
{ 
    public const int Baz = 2; 
} 

Answer 7

Ich würde wahrscheinlich eine Kombination von aufgezählten Bitfelder und Erweiterungsmethoden verwenden, um dies zu erreichen. Zum Beispiel:

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); 
    } 
} 

aktualisieren
In .NET 4, können Sie die Enum.HasFlag Methode verwenden, anstatt Ihre eigene Erweiterung rollen.

Answer 8

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

Answer 9

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

Answer 10

Dies ist eine alte Frage, aber ich habe mich kürzlich gefragt, ob so etwas möglich ist. Es scheint, dass es in C# keine Vererbung für Enums gibt und die einzige Möglichkeit, etwas wie dieses zu erstellen, wären benutzerdefinierte Klassen wie die Antwort von yoyo. Das Problem ist, dass es sich nicht wirklich um Enums handelt (kann z. B. nicht in switch-Anweisungen verwendet werden), und die Art des verschachtelten Codes erschwert das schnelle Lesen und Verstehen.

Ich fand, dass der einfachste Weg, um ähnliches Verhalten zu erhalten, war, eine einzelne, flache enum zu verwenden und die enums mit Attributen zu schmücken, die die Beziehungen (Vererbung) enthielten.Dies sorgt für viel einfacher zu lesen und zu verstehen, Code:

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 
} 

Jetzt können die Aufzählungen wie normale Aufzählungen verwendet werden, und wir können ihre Beziehungen mit ein paar einfachen Erweiterungsmethoden untersuchen:

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('.'); 
    } 

} 

-Test ähnlich wie Jo-Jos:

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>()); 
} 

das einzige, was ist der Punkt-Zugriff Syntax von verschachtelten Klassen fehlen, aber wenn Sie nicht kritische Performance Code zu schreiben sind, können Sie som achive ething ähnlich mit Dynamik:

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

Hinzufügen von Erweiterungsmethoden wie diese Sie Aufzählungen mit bestimmten Attributen zugreifen können, so dass Sie Variablen wie festlegen können:

Animal rhoda = Animals.dogs.greyhound; 
Animal felix = Animals.cats.persian;