Obtenir la valeur int de enum en C#

puisque les Énums peuvent être n'importe quel type intégral ( byte , int , short , etc.), une façon plus robuste d'obtenir la valeur intégrale sous-jacente de l'enum serait d'utiliser la méthode GetTypeCode en conjonction avec la classe Convert :

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

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

cela devrait fonctionner indépendamment du type intégral sous-jacent.

le déclarer 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 ensuite vous pouvez le référencer comme Question.Role , et il évalue toujours à un int ou ce que vous définissez comme.

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

donnera value == 2 .

sur une note apparentée, si vous voulez obtenir la valeur int de System.Enum , puis donné e ici:

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 laid. Je préfère la première.

c'est plus facile que vous le pensez - un enum 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

Enums augmentera de 1, et vous pouvez définir la valeur de départ. Sinon, il sera attribué à 0 initialement.

j'ai récemment converti de l'utilisation d'enums dans mon code en faveur de l'utilisation de la place avec des classes avec des constructeurs protégés et des instances statiques prédéfinies (grâce à Roelof - C# Ensure Valid Enum Values - Futureproof Method ).

à la lumière de cela, Voici comment j'aborderais maintenant cette question (y compris la conversion implicite à/de 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 vous obtenez tout ce que vous auriez de l'enum, mais votre code est maintenant beaucoup plus flexible, donc si vous avez besoin d'effectuer différentes actions basées sur la valeur de Question , vous pouvez mettre la logique dans Question lui-même (c.-à-d. dans le mode OO préféré) au lieu de mettre beaucoup d'énoncés de cas dans tout votre code pour aborder chaque scénario.

NB: réponse mise à jour 2018-04-27 pour utiliser les caractéristiques C# 6; c.-à-d. Les expressions de déclaration et lambda expression définitions du corps. Voir historique des révisions pour le code original. Cela a l'avantage de rendre la définition un peu moins verbeux; qui avait été l'un des principaux griefs à propos de cette réponse.

pour vous assurer qu'une valeur enum existe et ensuite la Parser, vous pouvez aussi faire ce qui 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() + ".");

j'espère que cela aidera.

Si vous voulez obtenir un entier pour les enum valeur qui est stockée dans une variable dont le type serait Question , à utiliser par exemple dans une méthode, vous pouvez simplement faire ce que 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 à 4 parce que la variable Geselecteerd est Talen.Nederlands . Si je le change en Talen.Portugees et rappelle la méthode, le texte passera à 3.

j'ai eu du mal à trouver ce simple solution sur internet et je n'ai pas pu la trouver, donc je testais quelque chose et j'ai découvert ceci. Espérons que cette aide. ;)

une autre façon de le faire:

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

résultera en:

Name: Role, Value: 2

peut-être que je l'ai manqué mais est-ce que quelqu'un a essayé une méthode d'extension générique simple. Cela fonctionne très bien pour moi. Vous pouvez éviter le cast de type dans votre API de cette façon, mais en fin de compte il en résulte une opération de type de changement. C'est un bon cas pour programmer Roselyn pour que le compilateur fasse une méthode GetValue 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;
    }
}    

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

...est une belle déclaration.

Vous ne devez lancer la suite de l'int de la sorte:

int Question = (int)QuestionType.Role

sinon, le type est toujours QuestionType .

Ce niveau de rigueur est le C#.

une alternative est d'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 lancer en code:

int Question = QuestionType.Role

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

vous pouvez le faire en mettant en œuvre une méthode D'Extension à votre type enum 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 enum actuelle:

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

ou

int value = Question.Role.getNumberValue();

int number = Question.Role.GetHashCode();

number doit avoir la valeur 2 .

Que Diriez - vous d'une méthode d'extension à la place:

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

et l'usage est légèrement plus joli:

var intValue = Question.Role.IntValue();

Mes fav hack avec des int ou des petits énumérations:

GetHashCode();

Pour un enum

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

ce

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

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

sorties

one
1
1  
max
2147483647
2147483647    
min
-2147483648
-2147483648    

clause de non-responsabilité: Ne fonctionne pas pour les énums basés sur long

ci-après est 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;
        }

la solution la plus simple que je puisse imaginer est de surcharger la méthode Get(int) comme ceci:

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

où [modifiers] peut généralement être identique à la méthode Get(int) . Si vous ne pouvez pas éditer la classe Questions ou si, pour une raison quelconque, vous ne le voulez 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);
    }
}

essayez celui-ci au lieu de convert enum à int:

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

l'exemple que je voudrais suggérer 'pour obtenir la valeur 'int' d'enum est, '

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

int answer = (int)Sample.Book;

maintenant la réponse sera 1.

j'espère que cela pourrait aider quelqu'un.

En Vb. 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)

puisque les enums peuvent être déclarés avec plusieurs types primitifs, une méthode d'extension générique pour lancer n'importe quel type d'enum 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;

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

essayez ceci:

int value = YourEnum.ToString("D");