Vraag Krijg int waarde van enum in C #


Ik heb een klas genaamd Questions (meervoud). In deze klasse is er een enum genoemd Question (enkelvoud) dat er zo uitziet.

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

In de Questions klas, ik heb een get(int foo) functie die een a retourneert Questions object daarvoor foo. Is er een gemakkelijke manier om de gehele waarde van de opsomming te krijgen, zodat ik iets als kan doen Questions.Get(Question.Role)?


1367
2018-06-03 06:46


oorsprong


antwoorden:


Werp gewoon het enum, b.v.

int something = (int) Question.Role;

Het bovenstaande werkt voor de overgrote meerderheid van enums die u in het wild ziet, als het standaard onderliggende type voor een opsomming is int.

Echter, als cecilphillip wijst erop dat enums verschillende onderliggende typen kunnen hebben. Als een enum wordt verklaard als een uint, longof ulong, het moet naar het type van het enum worden gegoten; bijv. voor

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

je zou ... moeten gebruiken

long something = (long)StarsInMilkyWay.Wolf424B;

1795
2018-06-03 06:49



Omdat Enums elk integraal type kan zijn (byte, int, short, enz.), zou een meer robuuste manier om de onderliggende integraalwaarde van de enum te krijgen, zijn om gebruik te maken van de GetTypeCode methode in combinatie met de Convert klasse:

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

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

Dit zou moeten werken ongeacht het onderliggende integrale type.


237
2017-07-09 14:54



Verklaar het als een statische klasse met openbare constanten:

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

En dan kun je ernaar verwijzen als Question.Role, en het evalueert altijd naar een int of hoe je het ook definieert.


162
2018-06-15 19:28



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

Zal resulteren in value == 2.


72
2018-06-03 06:48



In een verwante notitie, als u de. Wilt krijgen int waarde van System.Enum, dan gegeven e hier:

Enum e = Question.Role;

Je kunt gebruiken:

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

De laatste twee zijn gewoon lelijk. Ik geef de voorkeur aan de eerste.


54
2017-12-01 08:47



Het is makkelijker dan je denkt - een enum is al een int. Het moet gewoon worden herinnerd:

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

30
2018-06-03 06:51



Voorbeeld:

Public Enum EmpNo
{
    Raj = 1
    Rahul,
    Priyanka
}

En in de code erachter om enum-waarde te krijgen:

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

of

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

Enums zullen met 1 toenemen, en u kunt de startwaarde instellen. Anders zal het aanvankelijk als 0 worden toegewezen.


22
2017-09-25 10:43



Ik heb onlangs geconverteerd van het gebruik van enums in mijn code in plaats van het gebruik van klassen met beschermde constructors en vooraf gedefinieerde statische instanties (dankzij Roelof - C # Valid Enum-waarden garanderen - Futureproof-methode).

In het licht van dat, hieronder is hoe ik dit probleem nu zou benaderen (inclusief impliciete conversie van / naar 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)
}

Het voordeel van deze aanpak is dat je alles krijgt wat je zou hebben van de enum, maar je code is nu veel flexibeler, dus moet je verschillende acties uitvoeren op basis van de waarde van Question, je kunt logica in zetten Question zelf (d.w.z. op de gewenste OO-manier), in tegenstelling tot het plaatsen van veel case-statements in uw code om elk scenario aan te pakken.


NB: Antwoord bijgewerkt op 2018-04-27 om gebruik te kunnen maken van de functies van C # 6; d.w.z. verklaringsexpressies en lichaamseigen definities van lambda-expressie. Zien revisiegeschiedenis voor originele code. Dit heeft het voordeel dat de definitie iets minder breed is; dat was een van de belangrijkste klachten over de aanpak van dit antwoord.


18
2018-03-30 01:08



Om er zeker van te zijn dat er een enum-waarde bestaat en deze vervolgens te ontleden, kunt u ook het volgende doen.

// 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() + ".");

Ik hoop dat dit helpt.


12
2017-07-22 20:56