Obtenez de l'int valeur d'enum en C#

Depuis les Énumérations peuvent être n'importe quel type intégral (byte, int, short, etc.), d'une façon plus robuste pour obtenir le sous-jacent partie intégrante de la valeur de l'enum serait de faire usage de la GetTypeCode méthode en conjonction avec la Convert classe:

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 sous-jacent de type intégral.

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

Entraînera value == 2.

Il est plus facile que vous le pensez - un enum est déjà un int. Il a juste besoin d'être rappelé:

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

J'ai récemment converti à l'écart de l'utilisation des enums dans mon code en faveur de la place à l'aide de classes protégés, les constructeurs et les prédéfinis statique instances (grâce à Roelof - C# Assurer La Validité Des Valeurs Enum - Futureproof Méthode).

À la lumière de cela, ci-dessous comment j'aimerais maintenant aborder cette question (y compris la conversion implicite vers/à partir 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 que vous obtenez tout ce que vous avez de l'enum, mais votre code est maintenant beaucoup plus souple, donc si vous avez besoin d'effectuer des actions différentes en fonction de la valeur de Question, vous pouvez mettre de la logique dans Question lui-même (c'est à dire dans le préféré OO mode) plutôt que de mettre beaucoup de cas, les déclarations tout au long de votre code pour attaquer chaque scénario.

NB: Réponse mis à jour 2018-04-27 de rendre l'utilisation de C# 6 fonctions; c'est à dire la déclaration des expressions lambda et l'expression du corps définitions. Voir révision de l'histoire 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 de l'approche.

Pour assurer une valeur d'enum existe avant de l'analyser, vous pouvez également effectuer les opérations suivantes.

//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 cette aide.

Peut-être que j'ai manqué, mais quelqu'un a déjà essayé un simple générique de la méthode d'extension. Cela fonctionne très bien pour moi. Vous pouvez éviter le type de fonte dans votre API de cette façon, mais en fin de compte elle entraîne un changement du type d'opération. C'est une bonne affaire pour la programmation de Roselyn que le compilateur faire 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;
}
}    

int number = Question.Role.GetHashCode();

number doit avoir la valeur de 2.

Comment sur une extension de la méthode à la place:

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

Et l'utilisation est un peu 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    

Avertissement:
Ne fonctionne pas pour les énumérations, basée sur de longues

L'exemple, je voudrais suggérer "pour obtenir des" int " la valeur de l'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 peut aider quelqu'un.

La solution la plus simple je pense est de surcharger le Get(int) méthode comme ceci:

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

où [modifiers] peuvent généralement être la même que pour Get(int) méthode. Si Vous ne pouvez pas modifier le Questions classe ou pour une raison quelconque ne le souhaitez pas, Vous pouvez surcharger la méthode par l'écriture d'une extension:

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

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)

Essayez ceci :

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