C #: Est-il possible de classer les énumérations?

Question

Compte tenu de l'ENUM suivant:

    public enum Position
    {
        Quarterback,
        Runningback,
        DefensiveEnd,
        Linebacker
    };

Est-il possible de classer les constantes nommées, de sorte que je pouvais marquer « Quarterback » et « Runningback » comme des positions offensives et « defensive end » et « Le secondeur » comme des positions défensives?

Answer 1

Pourquoi ne pas BAISER:

class PlayerPosition {
    public enum Position {
        Quarterback,
        Runningback,
        DefensiveEnd,
        Linebacker
    }

    public enum Type {
        Offense,
        Defense
    }


    public static Type GetTypeForPosition(Position position) {
        switch (position) {
            case Quarterback:
            case Runningback:
                return Type.Offense;
            case DefensiveEnd:
            case Linebacker:
                return Type.Defense;

        }
    }
}

Answer 2

Vous pouvez utiliser des attributs:

public enum Position
{
    [OffensivePosition]
    Quarterback,
    [OffensivePosition]
    Runningback,
    [DefensivePosition]
    DefensiveEnd,
    [DefensivePosition]
    Linebacker
};

Et puis vérifier IsDefined sur un FieldInfo approprié. La syntaxe est pas très jolie, mais vous pouvez jeter dans quelques méthodes d'extension pour rendre les choses plus manageble:

public static bool IsOffensivePosition(PositionType pt)
{
    return typeof(PositionType).GetField(Enum.GetName(typeof(PositionType), pt)).
        IsDefined(typeof(OffensivePositionAttribute), false);
}

Answer 3

Vous pouvez utiliser un attribut, comme CategoryAttribute:

public enum Position
{
    [Category("Offensive")]
    Quarterback,
    [Category("Offensive")]
    Runningback,
    [Category("Defensive")]
    DefensiveEnd,
    [Category("Defensive")]
    Linebacker
};

Answer 4

public enum PositionType
{
    Offensive,
    Defensive,
}

public class PositionTypeAttribute : Attribute
{
    public PositionTypeAttribute(PositionType positionType)
    {
        PositionType = positionType;
    }
    public PositionType PositionType { get; private set; }
}

public enum Position
{
    [PositionType(PositionType.Offensive)]
    Quarterback,
    [PositionType(PositionType.Offensive)]
    Runningback,
    [PositionType(PositionType.Defensive)]
    DefensiveEnd,
    [PositionType(PositionType.Defensive)]
    Linebacker
};

public static class PositionHelper
{
    public static PositionType GetPositionType(this Position position)
    {
        var positionTypeAttr = (PositionTypeAttribute)typeof(Position).GetField(Enum.GetName(typeof(Position), position))
            .GetCustomAttributes(typeof(PositionTypeAttribute), false)[0];
        return positionTypeAttr.PositionType;

    }
}


Position position1 = Position.Runningback;
Console.WriteLine(position1.GetPositionType()); //print: Offensive

Position position2 = Position.Linebacker;
Console.WriteLine(position2.GetPositionType()); //print: Defensive

Answer 5

Vous pouvez utiliser Drapeaux

[Flags]
public enum Position
    {
        Quarterback = 1,
        Runningback = 2,
        DefensiveEnd = 4,
        Linebacker = 8,

        OffensivePosition = Quarterback | Runningback,
        DefensivePosition =  Linebacker | DefensiveEnd, 

    };

    //strictly for example purposes
    public bool isOffensive(Position pos)
    {
        return !((pos & OffensivePosition) == pos);
    }

Answer 6

Peut-être que vous pouvez essayer d'utiliser typesefe ENUM motif

class Position
{
    public bool Offensive { get; private set; }
    public bool Defensive { get; private set; }

    private Position()
    {
        Offensive = false;
        Defensive = false;
    }

    public static readonly Position Quarterback = new Position() { Offensive = true };
    public static readonly Position Runningback = new Position() { Offensive = true };
    public static readonly Position DefensiveEnd = new Position() { Defensive = true };
    public static readonly Position Linebacker = new Position() { Defensive = true };
}

Answer 7

Un sous-utilisé technique (mais parfaitement valable) est d'utiliser une classe qui définit un ensemble de constantes. En tant que classe, vous pouvez ajouter des propriétés supplémentaires qui peuvent décrire d'autres aspects de la valeur dénombrée. Curieusement, c'est la façon dont la plupart sont mises en œuvre dans les énumérations Java (qui ne dispose pas d'un mot-clé spécial pour eux).

Si vous allez dans cette voie, il est généralement une bonne idée de faire la classe scellée et définir un constructeur privé, de sorte que seule la classe elle-même peut définir des instances. Voici un exemple:

public static class Position 
{
    private PlayerPosition (string name, bool isDefensive ) {
        this.Name = name
        this.IsDefensive = isDefensive ;
    }
    // any properties you may need...
    public string Name { get; private set; }
    public bool IsDefensive { get; private set; }
    public bool IsOffensive { get { return !IsDefensive; } }

    // static instances that act like an enum
    public static readonly Quarterback = new PlayerPosition( "Quarterback", false );
    public static readonly Runningback = new PlayerPosition( "Runningback", false );
    public static readonly Linebacker = new PlayerPosition( "Linebacker", true );
    // etc...
}

En utilisant un tel résultat enum dans la syntaxe plus élégante et plus simple que les attributs:

if( PlayerPosition.Quarterback.IsDefensive )
{
    // ...
}

Answer 8

Vous pouvez utiliser une certaine forme de bits de drapeau. Mais cela pourrait conduire à un gâchis. Une meilleure façon peut être de créer simplement des classes personnalisées avec les détails que vous voulez et ensuite utiliser un dictionnaire pour rechercher chaque type de position;

public class PlayerPosition {
    public PlayerPosition (string positionName, bool isDefensive ) {
        this.Name = positionName;
        this.IsDefensive = isDefensive ;
    }
    public string Name { get; private set; }
    public bool IsDefensive { get; private set; }
}

... ENUM ...

[Flags]
public enum Positions {
    Quarterback = 0x21, 
    Runningback = 0x22, 
    DefensiveEnd = 0x14, 
    Linebacker = 0x18, 

    Defensive = 0x10,
    Offsensive = 0x20
}

Answer 9

Vous pouvez déclarer les énumérations dans une classe:

public class Position
{
    public enum Offensive { Quarterback = 1, RunningBack }
    public enum Defensive { DefensiveEnd = 10, LineBacker }
}

Notez que les valeurs défensives commencent à 10, de sorte que les valeurs ne se chevauchent pas. Vous ne précisez pas pourquoi vous voulez le faire, alors cela pourrait ne pas répondre à vos besoins.