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

1826

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)?

Jim
la source
31
Pour l'inverse: cast-int-to-enum-in-c-sharp .
nawfal
11
Je sais que je suis en retard à la fête, mais au lieu de définir votre méthode comme get(int foo)vous pouvez la définir comme get(Question foo)vous le feriez pour votre casting à l'intérieur de la méthode, vous pouvez appeler votre méthode commeQuestions.Get(Question.Role)
Joe

Réponses:

2355

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;
Tétraneutron
la source
23
@Harry ce n'est pas vrai. Vous pouvez créer une énumération sans lancer, ce n'est pas obligatoire. et je n'attribue de numéro que dans des cas particuliers, la plupart du temps, je le laisse comme valeur par défaut. mais vous pouvez faire enum Test { Item = 1 }et voir que 1 == (int)Test.Itemc'est égal.
Jaider
33
@Jaider (int)Test.ItemC'est un casting! () est l'opérateur de transtypage explicite.
Sinthia V
48
@Sinthia V, il a dit que vous pouvez le créer sans casting, ce qui est correct
Paul Ridgway
7
Si le type sous-jacent enum Questionn'était pas intmais longcette conversion tronquera la Rolevaleur intégrale de s!
quaylar
1
Lorsque vous acceptez un Enumcomme paramètre, vous savez que vous ne pouvez obtenir qu'un nombre fixe de valeurs intégrales possibles. D'un autre côté, si vous prenez simplement un int, alors vous devez valider si c'est intdans les valeurs acceptées., Compliquant ainsi le code. Vous pouvez toujours remplacer vos signatures comme `` `public void MyMethod (int x) {// faire quelque chose avec x} public void MyMethod (Enum x) {this.MyMethod ((int) x); } `` ``
percebus
307

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.

cecilphillip
la source
32
Cette technique m'a prouvé sa valeur lorsqu'il s'agissait d'un type générique où T: enum (en fait T: struct, IConvertible mais c'est une autre histoire).
aboy021
1
Comment modifieriez-vous cela pour imprimer la valeur hexadécimale de côté? Cet exemple montre la valeur décimale. Le problème est qu'il varest de type object, vous devez donc le déballer et cela devient plus compliqué que je ne le voudrais.
Mark Lakata
2
Je pense que vous devriez changer l'exemple en object val = Convert...etcle varsera toujours dans votre exemple object.
Mesh
2
@TimAbell Tout ce que je peux vraiment dire, c'est que nous avons constaté que les pages aspx compilées dynamiquement (où vous devez déployer les fichiers .cs sur le serveur en direct) attribuaient les entiers différemment à chaque valeur. Cela signifiait que les objets sérialisés sur une machine, se désérialisaient avec des valeurs différentes sur une machine différente et étaient effectivement corrompus (provoquant des heures de confusion). Nous l'avons soulevé avec MS et je semble me rappeler qu'ils ont dit que les entiers générés automatiquement n'étaient pas garantis d'être les mêmes lorsqu'ils étaient construits sur différentes versions de framework.
NickG
4
@TimAbell À une autre occasion, un développeur a supprimé une valeur Enum obsolète / inutilisée, entraînant la sortie de toutes les autres valeurs de la séquence. En tant que tel, nos normes de codage exigent désormais que les identifiants soient toujours spécifiés explicitement, sinon l'ajout / la suppression ou même le formatage automatique du code (par exemple le tri alphabétique) modifiera toutes les valeurs provoquant la corruption des données. Je conseillerais fortement à quiconque de spécifier explicitement tous les entiers Enum. Ceci est extrêmement important s'ils sont en corrélation avec des valeurs stockées en externe (base de données).
NickG
199

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.

PablosBicicleta
la source
31
J'utiliserais static readonly intparce que les constantes sont compilées dans leurs valeurs dures. Voir stackoverflow.com/a/755693/492
CAD bloke
96
Cette solution n'offre en fait pas le véritable avantage des énumérations fortement typées. Si je voulais seulement passer un paramètre GameState-enum à une méthode spécifique par exemple, le compilateur ne devrait pas me permettre de passer une variable int en tant que paramètre.
thgc
12
@CADBloke, c'est précisément la raison pour laquelle vous l'utiliseriez constet non pas static readonlyparce que chaque fois que vous comparez, static readonlyvous effectuez un appel de méthode pour obtenir la valeur de la variable alors qu'avec un constvous comparez directement deux types de valeur.
blockloop
3
@ brettof86 Oui, un const serait plus rapide, si la limitation de compilation ne sera jamais un problème alors tout ira bien.
CAD bloke
2
@Zack Je n'ai pas très bien expliqué cela, compilation limitationje veux dire que la valeur est codée en dur lorsque vous la compilez, donc toute modification de cette valeur nécessiterait que tous les assemblys l'utilisant doivent être recompilés. Je suis enclin à être d'accord avec vous sur l'utilisation, car la modification des valeurs aurait des implications importantes.
CAD bloke du
87
Question question = Question.Role;
int value = (int) question;

Se traduira par value == 2.

jerryjvl
la source
34
La question des variables temporaires n'est pas nécessaire.
Gishu
1
Donc quelque chose comme ça Questions.Get (Convert.ToInt16 (Question.Applications))
jim
6
Vous pouvez simplement lancer dans l'une ou l'autre direction; la seule chose à surveiller est que les énumérations n'appliquent rien (la valeur de l'énumération pourrait être 288, même si aucune question n'existe avec ce nombre)
Marc Gravell
@jim: Non, convertissez simplement la valeur: Questions.Get ((int) Question.Applications);
Guffa
1
@ Gishu On pourrait dire que c'est ... discutable. ;)
Felix D.
79

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.

nawfal
la source
1
Le second est cependant le plus rapide.
Johan B
1
En tant que personne habituée à utiliser Mixins dans le modding de Minecraft, le second semble être le gagnant évident.
Sollace
40

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
Michael Petrotta
la source
15
Nitpick: cette énumération est déjà un int. D'autres énumérations peuvent être de types différents - essayez "enum SmallEnum: byte {A, B, C}"
mqp
9
Absolument vrai. Référence C #: "Chaque type d'énumération a un type sous-jacent, qui peut être n'importe quel type intégral sauf char."
Michael Petrotta
33

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.

Peter Mortensen
la source
6
Est-ce que cela compile réellement?
Peter Mortensen
Est-ce que quelque chose qui est un Raj peut aussi être un Rahul ou un Priyanka? Vos valeurs entrent en conflit et doivent doubler pour être uniques, par exemple 0, 1, 2, 4, 8, etc. C'est ma principale préoccupation avec les énumérations.
Timothy Gonzalez
@TimothyGonzalez énumère en fait simplement compter 1 si vous ne spécifiez pas explicitement leur valeur;)
derHugo
@derHugo cela dépend si vous supposez que les valeurs numériques sont en base 10 ou en base 2.
Timothy Gonzalez
@TimothyGonzalez bien il n'y a pas grand chose à penser ... Je viens de le souligner que , par défaut , ils ne comptent que jusqu'à 1à l' intexception que vous définissez explicitement le contraire
derHugo
28

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.

JohnLBevan
la source
2
Je suppose que c'est le compromis entre la distribution explicite et le code que vous devez écrire pour le contourner. J'adore toujours la mise en œuvre, je souhaite juste qu'elle ne soit pas si longue. +1
Lankymart
3
J'ai utilisé plusieurs types différents de classes structurées de la même manière. Je trouve qu'ils font des merveilles en essayant de suivre la méthodologie "ne me laissez pas être un idiot plus tard".
James Haug
20

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.

Mathijs Van Der Slagt
la source
3
codage en néerlandais. Oh cher.
WiseStrawberry
Malheureusement, cette approche donne de mauvaises performances plus vous l'utilisez. Je l'ai essayé dans un de mes codes, et avec le temps, mon application est devenue de plus en plus lente, avec de moins en moins d'utilisation du processeur. Cela impliquait que les threads attendaient quelque chose - je suppose une sorte de garbage collection, probablement en raison de la mise en boîte du paramètre enum à ToInt32 (). En passant à un simple int.Parse (), j'ai pu éliminer complètement ces mauvaises performances et les performances sont restées les mêmes quelle que soit la durée d'exécution du code.
Greg
16

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() + ".");
Nathon
la source
14

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;
    }
}
Doug
la source
Peut-être parce que faire (int) customFlag est moins typé tout autour et fait plus ou moins la même chose?
Tim Keating
Re "Peut-être que je l'ai raté, mais quelqu'un a-t-il essayé une méthode d'extension générique simple ?" : SixOThree a dit "Utilisez une méthode d'extension à la place" et Bronek a dit "Vous pouvez le faire en implémentant une méthode d'extension à votre type d'enum défini" .
Peter Mortensen
13

Une autre façon de le faire:

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

Il en résultera:

Name: Role, Value: 2
plavozont
la source
12
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.

WonderWorker
la source
11
int number = Question.Role.GetHashCode();

numberdevrait avoir la valeur 2.

JaimeArmenta
la source
GetHashCode est un moyen d'obtenir de la valeur à partir du masque commun Enum
ThanhLD
Notez que ce n'est « légitime » pour bool*, byte, ushort, intet uint**. Le GetHashCode pour d'autres types modifie la valeur, par exemple fait quelques décalages de bits et xors. (* 1/0, ** casté en int bien sûr). Mais dans l'ensemble, ne faites pas cela sauf s'il s'agit de votre propre code privé.
AnorZaken
10

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();
Bronek
la source
5
Bronek, ce que vous avez fait, c'est inventer une syntaxe non informative grâce à une méthode d'extension (non générique btw) qui prend plus de temps à écrire. Je ne vois pas comment elle est meilleure que la solution originale de Tetraneutron. N'en faisons pas un chat, l'aide est toujours la bienvenue dans stackoverflow et tout le monde ici est là pour vous aider. Veuillez considérer mon commentaire comme une critique constructive.
Benjamin Gruenbaum
2
Benjamin, tout d'abord, pourquoi avez-vous supprimé mon commentaire? Je ne comprends pas vos décisions - peut-être que quelqu'un d'autre au sein de la communauté serait d'accord avec mon commentaire. Deuxièmement, ma solution enveloppe celle de Tetraneutron et avec précision, il est plus facile et moins d'écrire car IntelliSense propose une méthode d'extension. Je pense donc que votre décision n'est pas impartiale et représentative. Je vois beaucoup de réponses similaires sur Stack et c'est OK. Quoi qu'il en soit, j'utilise ma solution et peut-être que certaines personnes choisiraient ma solution à l'avenir, mais ces points négatifs le rendent plus difficile à trouver, surtout il est correct et non copiable.
Bronek
3
@Bronek Si vous ne me cinglez pas, je n'ai aucune indication que vous avez répondu. Je n'ai pas supprimé votre commentaire Je n'ai pas la possibilité ou je ne veux pas le faire. Un mod est probablement venu et l'a supprimé - vous pouvez le signaler à l'attention du modérateur et demander pourquoi ou mieux encore - demandez sur Meta Stack Overflow . J'ai une opinion sur votre solution du point de vue de la programmation qui est parfaitement à ma droite - c'est à cela que servent les commentaires pour commencer, pas besoin de la prendre personnellement.
Benjamin Gruenbaum
8

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();
SixOThree
la source
7
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);
}
Gauravsa
la source
costume - "10. (jeux de cartes) Chacun des jeux d'un jeu de cartes se distingue par la couleur et / ou des emblèmes spécifiques, tels que les piques, les cœurs, les diamants ou les clubs de cartes à jouer traditionnelles anglo, hispaniques et françaises."
Peter Mortensen
Une explication de l'exemple de code serait en règle (en modifiant votre réponse , pas ici dans les commentaires).
Peter Mortensen
zéro est généralement réservé à l'état non défini / inconnu dans les énumérations, inhabituel pour le définir comme ça
Chad Grant
6

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.

GinCanhViet
la source
1
Cela n'est vrai que si l'énumération s'inscrit dans un intbien sûr, car GetHashCoderenvoie un entier.
RB.
5

É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;
Jeffrey Ferreiras
la source
4

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;
}
Kamran Shahid
la source
4

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.

Erik Karlsson
la source
3

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

[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);
    }
}
Grx70
la source
3

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.

Vivek
la source
3

Utilisation:

Question question = Question.Role;
int value = Convert.ToInt32(question);
Peter Mortensen
la source
2

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;        
}
Nalan Madheswaran
la source
2

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)
VPP
la source
3
La question est pour C #.
Ctrl S
2
Le titre indique "Get int value from enum in C #" .
Peter Mortensen
0

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;
    }
Jeff
la source
s'il vous plaît non, vous pouvez faire tout cela en une seule ligne Convert.Changetype (e, e.GetTypeCode ()) et récupérer un objet, pas besoin de dynamique ou d'une méthode d'extension
Chad Grant
Je ne suis pas d'accord avec l'utilisation de Convert. Utiliser simplement un plâtre serait plus facile. Mon intention était de pouvoir convertir n'importe quelle énumération en sa valeur sans utiliser de transtypage. Cela permet de changer le type d'énumération sans devoir changer tous les transtypages associés - mais quand cela se produit-il?. La méthode d'extension fonctionne correctement. Cependant, j'ai un problème avec cela, car il est dynamique, le compliant ne peut pas taper check (pour la déclaration entière apparemment), ce qui signifie que la vérification de type se produit lors de l'exécution - ce n'est pas une bonne solution. Je pense que je vais revenir aux moulages.
Jeff
1
Je n'ai pas dit de l'utiliser sur le casting, juste que ce code est absurde et n'accomplit rien, en fait aggrave le problème. Je recommanderais de supprimer cette solution
Chad Grant