Récupère la valeur int de enum en C #

J'ai une classe appelée Questions(pluriel). Dans cette classe, il y a une énumération appelée Question(singulier) qui ressemble à ceci.

public enum Question
{
    Role = 2,
    ProjectFunding = 3,
    TotalEmployee = 4,
    NumberOfServers = 5,
    TopBusinessConcern = 6
}

Dans la Questionsclasse, j'ai une get(int foo)fonction qui renvoie un Questionsobjet pour cela foo. Existe-t-il un moyen facile de retirer la valeur entière de l'énumération pour que je puisse faire quelque chose comme ça Questions.Get(Question.Role)?

Il suffit de lancer l'énumération, par exemple

int something = (int) Question.Role;

Ce qui précède fonctionnera pour la grande majorité des énumérations que vous voyez dans la nature, comme le type sous-jacent par défaut pour une énumération int.

Cependant, comme le souligne cecilphillip , les énumérations peuvent avoir différents types sous-jacents. Si une ENUM est déclarée comme uint, longou ulong, il doit être jeté au type de ENUM; par exemple pour

enum StarsInMilkyWay:long {Sun = 1, V645Centauri = 2 .. Wolf424B = 2147483649};

Tu devrais utiliser

long something = (long)StarsInMilkyWay.Wolf424B;

Depuis énumérations peut être tout type intégral ( byte, int, short, etc.), d' une manière plus robuste pour obtenir la valeur intégrale sous - jacente de l'ENUM serait d'utiliser la GetTypeCodeméthode en conjonction avec la Convertclasse:

enum Sides {
    Left, Right, Top, Bottom
}
Sides side = Sides.Bottom;

object val = Convert.ChangeType(side, side.GetTypeCode());
Console.WriteLine(val);

Cela devrait fonctionner quel que soit le type intégral sous-jacent.

Déclarez-le comme une classe statique ayant des constantes publiques:

public static class Question
{
    public const int Role = 2;
    public const int ProjectFunding = 3;
    public const int TotalEmployee = 4;
    public const int NumberOfServers = 5;
    public const int TopBusinessConcern = 6;
}

Et puis vous pouvez le référencer en tant que Question.Role, et il évalue toujours un intou quoi que vous le définissiez comme.

Question question = Question.Role;
int value = (int) question;

Se traduira par value == 2.

Sur une note connexe, si vous souhaitez obtenir la intvaleur de System.Enum, alors donné eici:

Enum e = Question.Role;

Vous pouvez utiliser:

int i = Convert.ToInt32(e);
int i = (int)(object)e;
int i = (int)Enum.Parse(e.GetType(), e.ToString());
int i = (int)Enum.ToObject(e.GetType(), e);

Les deux derniers sont tout simplement laids. Je préfère le premier.

C'est plus facile que vous ne le pensez - une énumération est déjà un int. Il suffit de le rappeler:

int y = (int)Question.Role;
Console.WriteLine(y); // Prints 2

Exemple:

public Enum EmpNo
{
    Raj = 1,
    Rahul,
    Priyanka
}

Et dans le code derrière pour obtenir la valeur enum:

int setempNo = (int)EmpNo.Raj; // This will give setempNo = 1

ou

int setempNo = (int)EmpNo.Rahul; // This will give setempNo = 2

Les énumérations incrémentent de 1 et vous pouvez définir la valeur de départ. Si vous ne définissez pas la valeur de départ, elle sera affectée initialement à 0.

J'ai récemment converti l'utilisation d'énumérations dans mon code en faveur de l'utilisation de classes avec des constructeurs protégés et des instances statiques prédéfinies (grâce à Roelof - C # Assurer des valeurs d'énumération valides - Méthode Futureproof ).

À la lumière de cela, voici comment j'aborderais maintenant ce problème (y compris la conversion implicite vers / depuis int).

public class Question
{
    // Attributes
    protected int index;
    protected string name;
    // Go with a dictionary to enforce unique index
    //protected static readonly ICollection<Question> values = new Collection<Question>();
    protected static readonly IDictionary<int,Question> values = new Dictionary<int,Question>();

    // Define the "enum" values
    public static readonly Question Role = new Question(2,"Role");
    public static readonly Question ProjectFunding = new Question(3, "Project Funding");
    public static readonly Question TotalEmployee = new Question(4, "Total Employee");
    public static readonly Question NumberOfServers = new Question(5, "Number of Servers");
    public static readonly Question TopBusinessConcern = new Question(6, "Top Business Concern");

    // Constructors
    protected Question(int index, string name)
    {
        this.index = index;
        this.name = name;
        values.Add(index, this);
    }

    // Easy int conversion
    public static implicit operator int(Question question) =>
        question.index; //nb: if question is null this will return a null pointer exception

    public static implicit operator Question(int index) =>        
        values.TryGetValue(index, out var question) ? question : null;

    // Easy string conversion (also update ToString for the same effect)
    public override string ToString() =>
        this.name;

    public static implicit operator string(Question question) =>
        question?.ToString();

    public static implicit operator Question(string name) =>
        name == null ? null : values.Values.FirstOrDefault(item => name.Equals(item.name, StringComparison.CurrentCultureIgnoreCase));


    // If you specifically want a Get(int x) function (though not required given the implicit converstion)
    public Question Get(int foo) =>
        foo; //(implicit conversion will take care of the conversion for you)
}

L'avantage de cette approche est que vous obtenez tout ce que vous auriez de l'énumération, mais votre code est maintenant beaucoup plus flexible, donc si vous devez effectuer différentes actions en fonction de la valeur de Question, vous pouvez mettre la logique en Questionelle-même (c'est-à-dire dans l'OO préféré au lieu de mettre beaucoup de déclarations de cas dans votre code pour aborder chaque scénario.

NB: Réponse mise à jour le 2018-04-27 pour utiliser les fonctionnalités C # 6; c'est-à-dire les expressions de déclaration et les définitions de corps d'expression lambda. Voir l' historique des révisions pour le code d'origine. Cela a l'avantage de rendre la définition un peu moins détaillée; qui avait été l'une des principales plaintes concernant l'approche de cette réponse.

Si vous voulez obtenir un entier pour la valeur enum qui est stockée dans une variable, dont le type serait Question, à utiliser par exemple dans une méthode, vous pouvez simplement le faire, j'ai écrit dans cet exemple:

enum Talen
{
    Engels = 1, Italiaans = 2, Portugees = 3, Nederlands = 4, Duits = 5, Dens = 6
}

Talen Geselecteerd;    

public void Form1()
{
    InitializeComponent()
    Geselecteerd = Talen.Nederlands;
}

// You can use the Enum type as a parameter, so any enumeration from any enumerator can be used as parameter
void VeranderenTitel(Enum e)
{
    this.Text = Convert.ToInt32(e).ToString();
}

Cela changera le titre de la fenêtre en 4, car la variable Geselecteerdest Talen.Nederlands. Si je le change en Talen.Portugeeset rappelle la méthode, le texte changera en 3.

Pour vous assurer qu'une valeur d'énumération existe, puis l'analyser, vous pouvez également procéder comme suit.

// Fake Day of Week
string strDOWFake = "SuperDay";

// Real Day of Week
string strDOWReal = "Friday";

// Will hold which ever is the real DOW.
DayOfWeek enmDOW;

// See if fake DOW is defined in the DayOfWeek enumeration.
if (Enum.IsDefined(typeof(DayOfWeek), strDOWFake))
{
    // This will never be reached since "SuperDay"
    // doesn't exist in the DayOfWeek enumeration.
    enmDOW = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), strDOWFake);
}
// See if real DOW is defined in the DayOfWeek enumeration.
else if (Enum.IsDefined(typeof(DayOfWeek), strDOWReal))
{
    // This will parse the string into it's corresponding DOW enum object.
    enmDOW = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), strDOWReal);
}

// Can now use the DOW enum object.
Console.Write("Today is " + enmDOW.ToString() + ".");

Peut-être que je l'ai manqué, mais quelqu'un a-t-il essayé une méthode d'extension générique simple?

Cela fonctionne très bien pour moi. Vous pouvez éviter le transtypage de type dans votre API de cette façon, mais au final, il en résulte une opération de changement de type. C'est un bon cas pour programmer Roslyn pour que le compilateur crée une méthode GetValue <T> pour vous.

    public static void Main()
    {
        int test = MyCSharpWrapperMethod(TestEnum.Test1);

        Debug.Assert(test == 1);
    }

    public static int MyCSharpWrapperMethod(TestEnum customFlag)
    {
        return MyCPlusPlusMethod(customFlag.GetValue<int>());
    }

    public static int MyCPlusPlusMethod(int customFlag)
    {
        // Pretend you made a PInvoke or COM+ call to C++ method that require an integer
        return customFlag;
    }

    public enum TestEnum
    {
        Test1 = 1,
        Test2 = 2,
        Test3 = 3
    }
}

public static class EnumExtensions
{
    public static T GetValue<T>(this Enum enumeration)
    {
        T result = default(T);

        try
        {
            result = (T)Convert.ChangeType(enumeration, typeof(T));
        }
        catch (Exception ex)
        {
            Debug.Assert(false);
            Debug.WriteLine(ex);
        }

        return result;
    }
}

Une autre façon de le faire:

Console.WriteLine("Name: {0}, Value: {0:D}", Question.Role);

Il en résultera:

Name: Role, Value: 2

public enum QuestionType
{
    Role = 2,
    ProjectFunding = 3,
    TotalEmployee = 4,
    NumberOfServers = 5,
    TopBusinessConcern = 6
}

... est une belle déclaration.

Vous devez convertir le résultat en entier comme suit:

int Question = (int)QuestionType.Role

Sinon, le type est toujours QuestionType .

Ce niveau de rigueur est la voie C #.

Une alternative consiste à utiliser une déclaration de classe à la place:

public class QuestionType
{
    public static int Role = 2,
    public static int ProjectFunding = 3,
    public static int TotalEmployee = 4,
    public static int NumberOfServers = 5,
    public static int TopBusinessConcern = 6
}

C'est moins élégant à déclarer, mais vous n'avez pas besoin de le convertir en code:

int Question = QuestionType.Role

Vous pouvez également vous sentir plus à l'aise avec Visual Basic, qui répond à ce type d'attente dans de nombreux domaines.

int number = Question.Role.GetHashCode();

numberdevrait avoir la valeur 2.

Vous pouvez le faire en implémentant une méthode d'extension à votre type d'énumération défini:

public static class MyExtensions
{
    public static int getNumberValue(this Question questionThis)
    {
        return (int)questionThis;
    }
}

Cela simplifie l'obtention de la valeur int de la valeur d'énumération actuelle:

Question question = Question.Role;
int value = question.getNumberValue();

ou

int value = Question.Role.getNumberValue();

Utilisez plutôt une méthode d'extension:

public static class ExtensionMethods
{
    public static int IntValue(this Enum argEnum)
    {
        return Convert.ToInt32(argEnum);
    }
}

Et l'utilisation est un peu plus jolie:

var intValue = Question.Role.IntValue();

public enum Suit : int
{
    Spades = 0,
    Hearts = 1,
    Clubs = 2,
    Diamonds = 3
}

Console.WriteLine((int)(Suit)Enum.Parse(typeof(Suit), "Clubs"));

// From int
Console.WriteLine((Suit)1);

// From a number you can also
Console.WriteLine((Suit)Enum.ToObject(typeof(Suit), 1));

if (typeof(Suit).IsEnumDefined("Spades"))
{
    var res = (int)(Suit)Enum.Parse(typeof(Suit), "Spades");
    Console.Out.WriteLine("{0}", res);
}

Utilisation:

Question question = Question.Role;
int value = question.GetHashCode();

Il en résultera value == 2.

Cela n'est vrai que si l'énumération s'inscrit dans un int.

Étant donné que les énumérations peuvent être déclarées avec plusieurs types primitifs, une méthode d'extension générique pour convertir n'importe quel type d'énumération peut être utile.

enum Box
{
    HEIGHT,
    WIDTH,
    DEPTH
}

public static void UseEnum()
{
    int height = Box.HEIGHT.GetEnumValue<int>();
    int width = Box.WIDTH.GetEnumValue<int>();
    int depth = Box.DEPTH.GetEnumValue<int>();
}

public static T GetEnumValue<T>(this object e) => (T)e;

Voici la méthode d'extension

public static string ToEnumString<TEnum>(this int enumValue)
{
    var enumString = enumValue.ToString();
    if (Enum.IsDefined(typeof(TEnum), enumValue))
    {
        enumString = ((TEnum) Enum.ToObject(typeof (TEnum), enumValue)).ToString();
    }
    return enumString;
}

Mon hack préféré avec des énumérations int ou plus petites:

GetHashCode();

Pour une énumération

public enum Test
{
    Min = Int32.MinValue,
    One = 1,
    Max = Int32.MaxValue,
}

Cette,

var values = Enum.GetValues(typeof(Test));

foreach (var val in values)
{
    Console.WriteLine(val.GetHashCode());
    Console.WriteLine(((int)val));
    Console.WriteLine(val);
}

les sorties

one
1
1
max
2147483647
2147483647
min
-2147483648
-2147483648

Avertissement:

Cela ne fonctionne pas pour les énumérations basées sur une longue.

La solution la plus simple à laquelle je peux penser est de surcharger la Get(int)méthode comme ceci:

[modifiers] Questions Get(Question q)
{
    return Get((int)q);
}

où [modifiers]peut généralement être le même que pour la Get(int)méthode. Si vous ne pouvez pas modifier la Questionsclasse ou pour une raison quelconque ne le souhaitez pas, vous pouvez surcharger la méthode en écrivant une extension:

public static class Extensions
{
    public static Questions Get(this Questions qs, Question q)
    {
        return qs.Get((int)q);
    }
}

L'exemple que je voudrais suggérer "pour obtenir une valeur" int "à partir d'une énumération", est

public enum Sample
{
    Book = 1, 
    Pen = 2, 
    Pencil = 3
}

int answer = (int)Sample.Book;

Maintenant, la réponse sera 1.

Utilisation:

Question question = Question.Role;
int value = Convert.ToInt32(question);

Essayez celui-ci au lieu de convertir enum en int:

public static class ReturnType
{
    public static readonly int Success = 1;
    public static readonly int Duplicate = 2;
    public static readonly int Error = -1;        
}

En Visual Basic, il devrait être:

Public Enum Question
    Role = 2
    ProjectFunding = 3
    TotalEmployee = 4
    NumberOfServers = 5
    TopBusinessConcern = 6
End Enum

Private value As Integer = CInt(Question.Role)

Je suis venu avec cette méthode d'extension qui inclut les fonctionnalités du langage actuel. En utilisant dynamique, je n'ai pas besoin d'en faire une méthode générique et de spécifier le type qui maintient l'invocation plus simple et cohérente:

public static class EnumEx
{
    public static dynamic Value(this Enum e)
    {
        switch (e.GetTypeCode())
        {
            case TypeCode.Byte:
            {
                return (byte) (IConvertible) e;
            }

            case TypeCode.Int16:
            {
                return (short) (IConvertible) e;
            }

            case TypeCode.Int32:
            {
                return (int) (IConvertible) e;
            }

            case TypeCode.Int64:
            {
                return (long) (IConvertible) e;
            }

            case TypeCode.UInt16:
            {
                return (ushort) (IConvertible) e;
            }

            case TypeCode.UInt32:
            {
                return (uint) (IConvertible) e;
            }

            case TypeCode.UInt64:
            {
                return (ulong) (IConvertible) e;
            }

            case TypeCode.SByte:
            {
                return (sbyte) (IConvertible) e;
            }
        }

        return 0;
    }