Come convertire da System.Enum in numero intero di base?

Question

Mi piacerebbe creare un metodo generico per convertire qualsiasi tipo di System.Enum derivato al suo valore intero corrispondente, senza eseguire il cast e preferibilmente senza analizzare una stringa.

Ad esempio, quello che voglio è qualcosa di simile:

// Trivial example, not actually what I'm doing. 
class Converter 
{ 
    int ToInteger(System.Enum anEnum) 
    { 
     (int)anEnum; 
    } 
} 

Ma questo non sembra funzionare. Resharper segnala che non puoi trasmettere espressioni di tipo 'System.Enum' per digitare 'int'.

Ora ho trovato questa soluzione ma preferirei avere qualcosa di più efficiente.

class Converter 
{ 
    int ToInteger(System.Enum anEnum) 
    { 
     return int.Parse(anEnum.ToString("d")); 
    } 
} 

Qualche suggerimento?

Answer 1

Se non si vuole lanciare,

Convert.ToInt32() 

potrebbe fare il trucco.

Il cast diretto (tramite (int)enumValue) non è possibile. Si noti che questo sarebbe anche "pericoloso" poiché un enum può avere diversi tipi di sottostanti (int, long, byte ...).

Più formalmente: System.Enum non ha alcuna relazione diretta eredità con Int32 (anche se entrambi sono ValueType s), in modo che il cast esplicito non può essere corretto all'interno del sistema di tipo

Answer 2

La trasmissione da System.Enum a int funziona correttamente (è anche su MSDN). Forse è un bug di Resharper.

Answer 3

ho preso a lavorare per colata a un oggetto e poi to int:

public static class EnumExtensions 
{ 
    public static int ToInt(this Enum enumValue) 
    { 
     return (int)((object)enumValue); 
    } 
} 

Questo è brutto e probabilmente non è il modo migliore. Continuerò a scherzare, per vedere se riesco a inventarmi qualcosa di meglio ...

EDIT: stavo per pubblicare anche Convert.ToInt32 (enumValue) e ho notato che MartinStettner mi ha battuto ad esso.

public static class EnumExtensions 
{ 
    public static int ToInt(this Enum enumValue) 
    { 
     return Convert.ToInt32(enumValue); 
    } 
} 

prova:

int x = DayOfWeek.Friday.ToInt(); 
Console.WriteLine(x); // results in 5 which is int value of Friday 

EDIT 2: Nei commenti, qualcuno ha detto che questo funziona solo in C# 3.0. Ho appena provato questo in VS2005 come questo e ha funzionato:

public static class Helpers 
{ 
    public static int ToInt(Enum enumValue) 
    { 
     return Convert.ToInt32(enumValue); 
    } 
} 

    static void Main(string[] args) 
    { 
     Console.WriteLine(Helpers.ToInt(DayOfWeek.Friday)); 
    } 

Answer 4

non dimenticare che il tipo Enum in sé ha un sacco di funzioni di supporto statiche in esso. Se tutto ciò che si vuole fare è convertire un'istanza dell'enum nel suo tipo intero corrispondente, quindi il casting è probabilmente il modo più efficace.

Penso che ReSharper si stia lamentando perché Enum non è un'enumerazione di alcun tipo particolare e le enumerazioni derivano da un valore di tipo scalare, non Enum.Se avete bisogno di colata adattabili in modo generico, direi che questo potrebbe Suite È bene (notare che il tipo di enumerazione in sé è anche incluso nel generico:

public static EnumHelpers 
{ 
    public static T Convert<T, E>(E enumValue) 
    { 
     return (T)enumValue; 
    } 
} 

Questo potrebbe quindi essere utilizzato in questo modo:

public enum StopLight: int 
{ 
    Red = 1, 
    Yellow = 2, 
    Green = 3 
} 

// ... 

int myStoplightColor = EnumHelpers.Convert<int, StopLight>(StopLight.Red); 

non posso dire per certo fuori dalla parte superiore della mia testa, ma il codice di cui sopra potrebbe anche essere supportata da inferenza di tipo C# 's, permettendo la seguente:

int myStoplightColor = EnumHelpers.Convert<int>(StopLight.Red); 

Answer 5

Perché avete bisogno di reinventare ° e ruota con un metodo di supporto? È perfettamente legale trasmettere un valore enum al tipo sottostante.

E 'meno di battitura, e, a mio parere più leggibile, da usare ...

int x = (int)DayOfWeek.Tuesday; 

... piuttosto che qualcosa di simile ...

int y = Converter.ToInteger(DayOfWeek.Tuesday); 
// or 
int z = DayOfWeek.Tuesday.ToInteger(); 

Answer 6

Dalla mia risposta here:

Dato e come in:

Enum e = Question.Role; 

Poi questi lavori:

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

Gli ultimi due sono semplicemente brutto. Il primo dovrebbe essere più leggibile, anche se il secondo è molto più veloce. O potrebbe essere un metodo di estensione è il migliore, il meglio di entrambi i mondi.

public static int GetIntValue(this Enum e) 
{ 
    return e.GetValue<int>(); 
} 

public static T GetValue<T>(this Enum e) where T : struct, IComparable, IFormattable, IConvertible, IComparable<T>, IEquatable<T> 
{ 
    return (T)(object)e; 
} 

Ora è possibile chiamare:

e.GetValue<int>(); //or 
e.GetIntValue(); 

Answer 7

Se avete bisogno di convertire qualsiasi enum al tipo di fondo (non tutte le enumerazioni sono supportate da int) allora si può usare:

return System.Convert.ChangeType(
    enumValue, 
    Enum.GetUnderlyingType(enumValue.GetType()));