Immer den max-Wert eines enum

Question

Wie bekommt man den max-Wert einer enum?

Answer 1

Enum.GetValues() scheint eine Rückkehr der Werte in Ordnung, so etwas wie dieses:

// given this enum:
public enum Foo
{
    Fizz = 3, 
    Bar = 1,
    Bang = 2
}

// this gets Fizz
var lastFoo = Enum.GetValues(typeof(Foo)).Cast<Foo>().Last();

Bearbeiten

Für diejenigen, die nicht bereit und Lesen Sie die Kommentare:Sie können es auch tun, auf diese Weise:

var lastFoo = Enum.GetValues(typeof(Foo)).Cast<Foo>().Max();

...das funktioniert, wenn einige Ihrer enum-Werte sind negativ.

Answer 2

Ich bin mit Matts Antwort. Wenn Sie nur min und max int Werte benötigen, dann können Sie es wie folgt.

Maximum:

Enum.GetValues(typeof(Foo)).Cast<int>().Max();

Minimum:

Enum.GetValues(typeof(Foo)).Cast<int>().Min();

Answer 3

Laut Matt Hamilton Antwort, dachte ich für sie eine Verlängerung Methode zum Erstellen.

Da ValueType nicht als generische Typparameter Einschränkung akzeptiert wird, habe ich nicht einen besseren Weg finden T zu beschränken Enum aber die folgenden.

würde Irgendwelche Ideen wirklich zu schätzen.

PS. bitte meine VB implicitness ignorieren, ich liebe VB auf diese Weise verwendet wird, das ist die Stärke von VB und deshalb habe ich VB lieben.

Howeva, hier ist es:

C #:

static void Main(string[] args)
{
    MyEnum x = GetMaxValue<MyEnum>();
}

public static TEnum GetMaxValue<TEnum>() 
    where TEnum : IComparable, IConvertible, IFormattable
    //In C#>=7.3 substitute with 'where TEnum : Enum', and remove the following check:
{
    Type type = typeof(TEnum);

    if (!type.IsSubclassOf(typeof(Enum)))
        throw new
            InvalidCastException
                ("Cannot cast '" + type.FullName + "' to System.Enum.");

    return (TEnum)Enum.ToObject(type, Enum.GetValues(type).Cast<int>().Last());
}

enum MyEnum
{
    ValueOne,
    ValueTwo
}

VB:

Public Function GetMaxValue _
    (Of TEnum As {IComparable, IConvertible, IFormattable})() As TEnum

    Dim type = GetType(TEnum)

    If Not type.IsSubclassOf(GetType([Enum])) Then _
        Throw New InvalidCastException _
            ("Cannot cast '" & type.FullName & "' to System.Enum.")

    Return [Enum].ToObject(type, [Enum].GetValues(type) _
                        .Cast(Of Integer).Last)
End Function

Answer 4

Das ist etwas pingelig, aber der tatsächliche Maximalwert jeder ENUM ist Int32.MaxValue (vorausgesetzt, es ist ein Enum von int abgeleitet). Es ist vollkommen legal jede Int32-Wert zu einem beliebigen Enum zu werfen, unabhängig davon, ob es sich tatsächlich mit diesem Wert ein Mitglied erklärt.

Legal:

enum SomeEnum
{
    Fizz = 42
}

public static void SomeFunc()
{
    SomeEnum e = (SomeEnum)5;
}

Answer 5

Nach einer anderen Zeit versuchen, bekam ich diese Erweiterung Methode:

public static class EnumExtension
{
    public static int Max(this Enum enumType)
    {           
        return Enum.GetValues(enumType.GetType()).Cast<int>().Max();             
    }
}

class Program
{
    enum enum1 { one, two, second, third };
    enum enum2 { s1 = 10, s2 = 8, s3, s4 };
    enum enum3 { f1 = -1, f2 = 3, f3 = -3, f4 };

    static void Main(string[] args)
    {
        Console.WriteLine(enum1.one.Max());        
    }
}

Answer 6

Mit der letzten Funktion nicht den maximalen Wert bekommen. Verwenden Sie die „max“ -Funktion konnte. Wie:

 class Program
    {
        enum enum1 { one, two, second, third };
        enum enum2 { s1 = 10, s2 = 8, s3, s4 };
        enum enum3 { f1 = -1, f2 = 3, f3 = -3, f4 };

        static void Main(string[] args)
        {
            TestMaxEnumValue(typeof(enum1));
            TestMaxEnumValue(typeof(enum2));
            TestMaxEnumValue(typeof(enum3));
        }

        static void TestMaxEnumValue(Type enumType)
        {
            Enum.GetValues(enumType).Cast<Int32>().ToList().ForEach(item =>
                Console.WriteLine(item.ToString()));

            int maxValue = Enum.GetValues(enumType).Cast<int>().Max();     
            Console.WriteLine("The max value of {0} is {1}", enumType.Name, maxValue);
        }
    }

Answer 7

In Übereinstimmung mit Matthew J Sullivan, für C #:

   Enum.GetValues(typeof(MyEnum)).GetUpperBound(0);

Ich bin wirklich nicht sicher, warum jemand verwenden möchte:

   Enum.GetValues(typeof(MyEnum)).Cast<MyEnum>().Last();

... Als Wort-für-Wort, semantisch gesprochen, es scheint nicht so viel Sinn zu machen? (Immer gut verschiedene Möglichkeiten zu haben, aber ich habe nicht den Nutzen in letzterem sehen.)

Answer 8

Es gibt Methoden für das abrufen von Informationen über Aufzählungstypen unter System.Enum.

Also, in einem VB.Net Projekt in Visual Studio kann ich geben " - System.Enum." und die intellisense bringt alle Arten von Güte.

Eine Methode ist insbesondere System.Enum.GetValues () gibt ein array mit den aufgezählten Werte.Sobald Sie haben das array, sollten Sie in der Lage sein zu tun, was angemessen ist für Ihre besonderen Umstände.

In meinem Fall, meine aufgezählten Werte wieder bei null angefangen und übersprungen keine zahlen, so um den max-Wert für meine enum-ich muss nur wissen, wie viele Elemente im array.

VB.Net code-snippets:

'''''''

Enum MattType
  zerothValue         = 0
  firstValue          = 1
  secondValue         = 2
  thirdValue          = 3
End Enum

'''''''

Dim iMax      As Integer

iMax = System.Enum.GetValues(GetType(MattType)).GetUpperBound(0)

MessageBox.Show(iMax.ToString, "Max MattType Enum Value")

'''''''

Answer 9

In F #, mit einer Hilfsfunktion, die Enum in eine Sequenz zu konvertieren:

type Foo =
    | Fizz  = 3
    | Bang  = 2

// Helper function to convert enum to a sequence. This is also useful for iterating.
// stackoverflow.com/questions/972307/can-you-loop-through-all-enum-values-c
let ToSeq (a : 'A when 'A : enum<'B>) =
    Enum.GetValues(typeof<'A>).Cast<'B>()

// Get the max of Foo
let FooMax = ToSeq (Foo()) |> Seq.max   

Beim Laufen es ...

> type Foo = | Fizz = 3 | Bang = 2
> val ToSeq : 'A -> seq<'B> when 'A : enum<'B>
> val FooMax : Foo = Fizz

Die when 'A : enum<'B> wird nicht durch den Compiler für die Definition erforderlich, werden jedoch für jeden Einsatz von ToSeq erforderlich, auch durch einen gültigen Aufzählungstyp.

Answer 10

Es ist unter allen Umständen nicht verwendbar, sondern definiere ich oft den maximalen Wert selbst:

enum Values {
  one,
  two,
  tree,
  End,
}

for (Values i = 0; i < Values.End; i++) {
  Console.WriteLine(i);
}

var random = new Random();
Console.WriteLine(random.Next((int)Values.End));

Natürlich wird dies nicht funktionieren, wenn Sie benutzerdefinierte Werte in einer ENUM verwenden, aber oft kann es eine einfache Lösung sein.