Trovare il valore più alto in un'enumerazione

Question

Sto scrivendo un metodo che determina il valore più alto in un'enumerazione .NET in modo da poter creare un BitArray con un bit per ogni valore enum:

pressedKeys = new BitArray(highestValueInEnum<Keys>()); 

Ho bisogno di questo su due enumerazioni differenti, così ho girato in un metodo generico:

/// <summary>Returns the highest value encountered in an enumeration</summary> 
/// <typeparam name="EnumType"> 
/// Enumeration of which the highest value will be returned 
/// </typeparam> 
/// <returns>The highest value in the enumeration</returns> 
private static int highestValueInEnum<EnumType>() { 
    int[] values = (int[])Enum.GetValues(typeof(EnumType)); 
    int highestValue = values[0]; 
    for(int index = 0; index < values.Length; ++index) { 
    if(values[index] > highestValue) { 
     highestValue = values[index]; 
    } 
    } 

    return highestValue; 
} 

Come potete vedere, sto gettando il valore di ritorno di Enum.GetValues ​​() per int [], non EnumType []. Questo perché non posso eseguire il cast di EnumType (che è un parametro di tipo generico) su int successivamente.

Il codice funziona. Ma è valido? Posso sempre trasmettere il ritorno da Enum.GetValues ​​() a int []?

Answer 1

No, non è possibile trasmettere in modo sicuro a int[]. I tipi Enum non utilizzano sempre int come valore sottostante. Se ti limiti ai tipi enum che fanno hanno un tipo sottostante di int, dovrebbe comunque andare bene.

Questo si sente come qualcosa che (o io) potrebbe estendersi Unconstrained Melody per sostenere se si voleva - in un modo che realmente vincolato al tipo di essere un tipo enum in fase di compilazione, e ha lavorato per qualsiasi tipo enum, anche quelli con basi sottostanti come long e ulong.

Senza melodia non vincolata, è comunque possibile farlo in modo generale utilizzando il fatto che tutti i tipi di enumerazione implementano in modo efficace IComparable in modo appropriato. Se si utilizza .NET 3.5 è un one-liner:

private static TEnum GetHighestValue<TEnum>() { 
    return Enum.GetValues(typeof(TEnum)).Cast<TEnum>().Max(); 
} 

Answer 2

Facile! Usando LINQ il tuo loop può essere sostituito con due linee di codice, o solo uno se vuoi mescolarlo tutto insieme.

public partial class Form1 : Form 
{ 
    private void Form1_Load(object sender, EventArgs e) 
    { 
     MyEnum z = MyEnum.Second; 
     z++; 
     z++; 

     //see if a specific value is defined in the enum: 
     bool isInTheEnum = !Enum.IsDefined(typeof(MyEnum), z); 

     //get the max value from the enum: 
     List<int> allValues = new List<int>(Enum.GetValues(typeof(MyEnum)).Cast<int>()); 
     int maxValue = allValues.Max(); 
    } 


} 

public enum MyEnum 
{ 
    Zero = 0, 
    First = 1, 
    Second = 2, 
    Third = 3 
} 

Answer 3

Secondo il consiglio di Jon Skeet (e grazie anche, slugster), questo è il codice aggiornato, ora utilizzando IComparable perché sto ancora mira NET 2.0.

/// <summary>Returns the highest value encountered in an enumeration</summary> 
/// <typeparam name="EnumType"> 
/// Enumeration of which the highest value will be returned 
/// </typeparam> 
/// <returns>The highest value in the enumeration</returns> 
private static EnumType highestValueInEnum<EnumType>() where EnumType : IComparable { 
    EnumType[] values = (EnumType[])Enum.GetValues(typeof(EnumType)); 
    EnumType highestValue = values[0]; 
    for(int index = 0; index < values.Length; ++index) { 
    if(values[index].CompareTo(highestValue) > 0) { 
     highestValue = values[index]; 
    } 
    } 

    return highestValue; 
} 

Per chiunque afferrare il codice, si potrebbe desiderare di aggiungere un ulteriore controllo in modo da non saltare in aria su enumerazioni vuote.