Come convertire da System.Enum a intero di base?

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

Ad esempio, quello che voglio è qualcosa del genere:

// 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 è possibile eseguire il cast di un'espressione di tipo "System.Enum" nel tipo "int".

Ora ho escogitato questa soluzione, ma preferisco qualcosa di più efficiente.

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

Eventuali suggerimenti?

Se non vuoi trasmettere,

Convert.ToInt32()

potrebbe fare il trucco.

Il cast diretto (via (int)enumValue) non è possibile. Si noti che questo sarebbe anche "pericoloso", in quanto un enum può avere diversi tipi di base ( int, long, byte...).

Più formalmente: System.Enumnon ha una relazione di ereditarietà diretta con Int32(sebbene entrambi siano ValueTypes), quindi il cast esplicito non può essere corretto all'interno del sistema di tipi

L'ho fatto funzionare eseguendo il casting su un oggetto e poi su un 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 giocarci, per vedere se riesco a trovare qualcosa di meglio ...

EDIT: Stavo per postare che Convert.ToInt32 (enumValue) funziona e ho notato che MartinStettner mi ha battuto.

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

Test:

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 funziona solo in C # 3.0. L'ho appena testato in VS2005 in questo modo 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));
    }

Se è necessario convertire qualsiasi enumerazione nel tipo sottostante (non tutte le enumerazioni sono supportate da int), è possibile utilizzare:

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

Perché hai bisogno di reinventare la ruota con un metodo di supporto? È perfettamente legale enumattribuire un valore al suo tipo sottostante.

È meno digitazione 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();

Dalla mia risposta qui :

Dato ecome in:

Enum e = Question.Role;

Quindi questi funzionano:

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 brutti. Il primo dovrebbe essere più leggibile, anche se il secondo è molto più veloce. O può essere un metodo di estensione è il migliore, il migliore 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;
}

Adesso puoi chiamare:

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

Il casting da a System.Enuma an intfunziona bene per me (è anche su MSDN ). Forse è un bug di Resharper.

Poiché gli enum sono limitati a byte, sbyte, short, ushort, int, uint, long e ulong, possiamo fare alcune ipotesi.

Possiamo evitare eccezioni durante la conversione utilizzando il contenitore più grande disponibile. Sfortunatamente, quale contenitore utilizzare non è chiaro perché ulong esploderà per numeri negativi e long per numeri compresi tra long.MaxValue e ulong.MaxValue. Dobbiamo passare da una scelta all'altra in base al tipo sottostante.

Ovviamente, devi ancora decidere cosa fare quando il risultato non rientra in un int. Penso che il casting vada bene, ma ci sono ancora alcuni trucchi:

1. per le enumerazioni basate su un tipo con uno spazio di campo più grande di int (long e ulong), è possibile che alcune enumerazioni restituiscano lo stesso valore.
2. il cast di un numero maggiore di int.MaxValue genererà un'eccezione se ti trovi in ​​una regione selezionata.

Ecco il mio suggerimento, lascio al lettore decidere dove esporre questa funzione; come aiutante o come estensione.

public int ToInt(Enum e)
{
  unchecked
  {
    if (e.GetTypeCode() == TypeCode.UInt64)
      return (int)Convert.ToUInt64(e);
    else
      return (int)Convert.ToInt64(e);
  }
}

Non dimenticare che il tipo Enum stesso contiene un sacco di funzioni di supporto statiche. Se tutto ciò che vuoi fare è convertire un'istanza di enum nel suo tipo intero corrispondente, il casting è probabilmente il modo più efficiente.

Penso che ReSharper si stia lamentando perché Enum non è un'enumerazione di alcun tipo particolare e le enumerazioni stesse derivano da un tipo di valore scalare, non da Enum. Se hai bisogno di casting adattabili in modo generico, direi che questo potrebbe adattarti bene (nota che il tipo di enumerazione stesso è incluso anche 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 dirlo con certezza dalla cima della mia testa, ma il codice sopra potrebbe persino essere supportato dall'inferenza del tipo di C #, consentendo quanto segue:

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