zählen - Wie zähle ich eine Aufzählung in C#auf?




c# wörter zählen (18)

foreach (Suit suit in Enum.GetValues(typeof(Suit))) { }

Ich habe vage Gerüchte gehört, dass dies extrem langsam ist. Weiß jemand? - Orion Edwards 15. Oktober 08 um 01.31 Uhr 7

Ich denke, das Cachen des Arrays würde es erheblich beschleunigen. Es sieht so aus, als ob Sie jedes Mal ein neues Array erhalten (durch Reflektion). Lieber:

Array enums = Enum.GetValues(typeof(Suit));
foreach (Suit suitEnum in enums) 
{
    DoSomething(suitEnum);
}

Das ist wenigstens ein bisschen schneller, ja?

Wie können Sie eine enum in C # enum ?

Der folgende Code wird beispielsweise nicht kompiliert:

public enum Suit 
{
    Spades,
    Hearts,
    Clubs,
    Diamonds
}

public void EnumerateAllSuitsDemoMethod() 
{
    foreach (Suit suit in Suit) 
    {
        DoSomething(suit);
    }
}

Und gibt den folgenden Kompilierungsfehler:

'Anzug' ist ein 'Typ', wird aber wie eine 'Variable' verwendet

Bei dem Suit Schlüsselwort, dem zweiten, schlägt dies fehl.


Ich glaube nicht, dass dies besser oder sogar gut ist und nur eine andere Lösung angibt.

Wenn die Aufzählungswerte streng zwischen 0 und n - 1 liegen, eine generische Alternative:

public void EnumerateEnum<T>()
{
    int length = Enum.GetValues(typeof(T)).Length;
    for (var i = 0; i < length; i++)
    {
        var @enum = (T)(object)i;
    }
}

Wenn die Aufzählungswerte zusammenhängend sind und Sie das erste und das letzte Element der Aufzählung angeben können, gilt Folgendes:

public void EnumerateEnum()
{
    for (var i = Suit.Spade; i <= Suit.Diamond; i++)
    {
        var @enum = i;
    }
}

aber das ist keine strikte Aufzählung, sondern nur eine Schleife. Die zweite Methode ist jedoch viel schneller als jeder andere Ansatz ...


Drei Wege:

1. Enum.GetValues(type) //since .NET 1.1, not in silverlight or compact framewok
2. type.GetEnumValues() //only on .NET 4 and above
3. type.GetFields().Where(x => x.IsLiteral).Select(x => x.GetValue(null)) //works everywhere

Ich GetEnumValues nicht, warum GetEnumValues in der GetEnumValues eingeführt wurde. Es ist für mich überhaupt nicht lesbar.

Eine Hilfsklasse wie Enum<T> ist für mich am lesbarsten und denkwürdigsten:

public static class Enum<T> where T : struct, IComparable, IFormattable, IConvertible
{
    public static IEnumerable<T> GetValues()
    {
        return (T[])Enum.GetValues(typeof(T));
    }

    public static IEnumerable<string> GetNames()
    {
        return Enum.GetNames(typeof(T));
    }
}

Jetzt rufst du an:

Enum<Suit>.GetValues();
//or
Enum.GetValues(typeof(Suit)); //pretty consistent style

Man kann auch eine Art Zwischenspeicherung verwenden, wenn die Leistung von Belang ist

public static class Enum<T> where T : struct, IComparable, IFormattable, IConvertible
{
    //lazily loaded
    static T[] values;
    static string[] names;

    public static IEnumerable<T> GetValues()
    {
        return values ?? (values = (T[])Enum.GetValues(typeof(T)));
    }

    public static IEnumerable<string> GetNames()
    {
        return names ?? (names = Enum.GetNames(typeof(T)));
    }
}

Eine einfache und generische Methode, ein Enum in etwas umzuwandeln, das Sie interagieren können:

public static Dictionary<int, string> ToList<T>() where T : struct
{
   return ((IEnumerable<T>)Enum
       .GetValues(typeof(T)))
       .ToDictionary(
           item => Convert.ToInt32(item),
           item => item.ToString());
}

Und dann:

var enums = EnumHelper.ToList<MyEnum>();

Es gibt zwei Möglichkeiten, eine Enum zu durchlaufen:

1. var values =  Enum.GetValues(typeof(myenum))
2. var values =  Enum.GetNames(typeof(myenum))

Der erste gibt Ihnen Werte in Form für ein Array von object und der zweite gibt Ihnen Werte in Form eines Arrays von String .

Verwenden Sie es in der foreach Schleife wie folgt:

foreach(var value in values)
{
    //Do operations here
}

Es sieht für mich so aus, als würden Sie wirklich die Namen der einzelnen Enummen ausgeben und nicht die Werte. In diesem Fall scheint Enum.GetNames() der richtige Ansatz zu sein.

public enum Suits
{
    Spades,
    Hearts,
    Clubs,
    Diamonds,
    NumSuits
}

public void PrintAllSuits()
{
    foreach (string name in Enum.GetNames(typeof(Suits)))
    {
        System.Console.WriteLine(name);
    }
}

Das Inkrementieren des Wertes ist übrigens keine gute Möglichkeit, die Werte einer Aufzählung aufzuzählen. Sie sollten dies stattdessen tun.

Ich würde stattdessen Enum.GetValues(typeof(Suit)) verwenden.

public enum Suits
{
    Spades,
    Hearts,
    Clubs,
    Diamonds,
    NumSuits
}

public void PrintAllSuits()
{
    foreach (var suit in Enum.GetValues(typeof(Suits)))
    {
        System.Console.WriteLine(suit.ToString());
    }
}

Hier ist ein Arbeitsbeispiel zum Erstellen von Auswahloptionen für eine DDL

var resman = ViewModelResources.TimeFrame.ResourceManager;

ViewBag.TimeFrames = from MapOverlayTimeFrames timeFrame 
      in Enum.GetValues(typeof(MapOverlayTimeFrames))
      select new SelectListItem
      {
         Value = timeFrame.ToString(),
         Text = resman.GetString(timeFrame.ToString()) ?? timeFrame.ToString()
      };

Ich denke du kannst verwenden

Enum.GetNames(Suit)

Ich habe einige Erweiterungen für die einfache Verwendung von Enummen gemacht, vielleicht kann sie jemand verwenden ...

public static class EnumExtensions
{
    /// <summary>
    /// Gets all items for an enum value.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value">The value.</param>
    /// <returns></returns>
    public static IEnumerable<T> GetAllItems<T>(this Enum value)
    {
        foreach (object item in Enum.GetValues(typeof(T)))
        {
            yield return (T)item;
        }
    }

    /// <summary>
    /// Gets all items for an enum type.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value">The value.</param>
    /// <returns></returns>
    public static IEnumerable<T> GetAllItems<T>() where T : struct
    {
        foreach (object item in Enum.GetValues(typeof(T)))
        {
            yield return (T)item;
        }
    }

    /// <summary>
    /// Gets all combined items from an enum value.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value">The value.</param>
    /// <returns></returns>
    /// <example>
    /// Displays ValueA and ValueB.
    /// <code>
    /// EnumExample dummy = EnumExample.Combi;
    /// foreach (var item in dummy.GetAllSelectedItems<EnumExample>())
    /// {
    ///    Console.WriteLine(item);
    /// }
    /// </code>
    /// </example>
    public static IEnumerable<T> GetAllSelectedItems<T>(this Enum value)
    {
        int valueAsInt = Convert.ToInt32(value, CultureInfo.InvariantCulture);

        foreach (object item in Enum.GetValues(typeof(T)))
        {
            int itemAsInt = Convert.ToInt32(item, CultureInfo.InvariantCulture);

            if (itemAsInt == (valueAsInt & itemAsInt))
            {
                yield return (T)item;
            }
        }
    }

    /// <summary>
    /// Determines whether the enum value contains a specific value.
    /// </summary>
    /// <param name="value">The value.</param>
    /// <param name="request">The request.</param>
    /// <returns>
    ///     <c>true</c> if value contains the specified value; otherwise, <c>false</c>.
    /// </returns>
    /// <example>
    /// <code>
    /// EnumExample dummy = EnumExample.Combi;
    /// if (dummy.Contains<EnumExample>(EnumExample.ValueA))
    /// {
    ///     Console.WriteLine("dummy contains EnumExample.ValueA");
    /// }
    /// </code>
    /// </example>
    public static bool Contains<T>(this Enum value, T request)
    {
        int valueAsInt = Convert.ToInt32(value, CultureInfo.InvariantCulture);
        int requestAsInt = Convert.ToInt32(request, CultureInfo.InvariantCulture);

        if (requestAsInt == (valueAsInt & requestAsInt))
        {
            return true;
        }

        return false;
    }
}

Die Enum selbst muss mit dem FlagsAttribute

[Flags]
public enum EnumExample
{
    ValueA = 1,
    ValueB = 2,
    ValueC = 4,
    ValueD = 8,
    Combi = ValueA | ValueB
}

Ich verwende ToString (), spalte dann das Spucker-Array in Flags auf.

[Flags]
public enum ABC {
   a = 1,
   b = 2,
   c = 4
};

public IEnumerable<ABC> Getselected (ABC flags)
{
   var values = flags.ToString().Split(',');
   var enums = values.Select(x => (ABC)Enum.Parse(typeof(ABC), x.Trim()));
   return enums;
}

ABC temp= ABC.a | ABC.b;
var list = getSelected (temp);
foreach (var item in list)
{
   Console.WriteLine(item.ToString() + " ID=" + (int)item);
}

In Silverlight erhalten Sie keine Enum.GetValues() .

Originaler Blogbeitrag von Einar Ingebrigtsen :

public class EnumHelper
{
    public static T[] GetValues<T>()
    {
        Type enumType = typeof(T);

        if (!enumType.IsEnum)
        {
            throw new ArgumentException("Type '" + enumType.Name + "' is not an enum");
        }

        List<T> values = new List<T>();

        var fields = from field in enumType.GetFields()
                     where field.IsLiteral
                     select field;

        foreach (FieldInfo field in fields)
        {
            object value = field.GetValue(enumType);
            values.Add((T)value);
        }

        return values.ToArray();
    }

    public static object[] GetValues(Type enumType)
    {
        if (!enumType.IsEnum)
        {
            throw new ArgumentException("Type '" + enumType.Name + "' is not an enum");
        }

        List<object> values = new List<object>();

        var fields = from field in enumType.GetFields()
                     where field.IsLiteral
                     select field;

        foreach (FieldInfo field in fields)
        {
            object value = field.GetValue(enumType);
            values.Add(value);
        }

        return values.ToArray();
    }
}

Sie können auch mithilfe der Reflektion direkt an die öffentlichen statischen Mitglieder des Enums binden.

typeof(Suit).GetMembers(BindingFlags.Public | BindingFlags.Static)
    .ToList().ForEach(x => DoSomething(x.Name));

Warum verwendet niemand Cast<T> ?

var suits = Enum.GetValues(typeof(Suit)).Cast<Suit>();

Da gehst du IEnumerable<Suit> .


Was ist, wenn Sie wissen, dass der Typ eine enum , aber Sie wissen nicht, welcher Typ zum Zeitpunkt des Kompilierens genau ist?

public class EnumHelper
{
    public static IEnumerable<T> GetValues<T>()
    {
        return Enum.GetValues(typeof(T)).Cast<T>();
    }

    public static IEnumerable getListOfEnum(Type type)
    {
        MethodInfo getValuesMethod = typeof(EnumHelper).GetMethod("GetValues").MakeGenericMethod(type);
        return (IEnumerable)getValuesMethod.Invoke(null, null);
    }
}

Die Methode getListOfEnum verwendet die Reflektion, um einen beliebigen Aufzählungstyp zu verwenden, und gibt eine IEnumerable aller Aufzählungswerte zurück.

Verwendungszweck:

Type myType = someEnumValue.GetType();

IEnumerable resultEnumerable = getListOfEnum(myType);

foreach (var item in resultEnumerable)
{
    Console.WriteLine(String.Format("Item: {0} Value: {1}",item.ToString(),(int)item));
}

Wenn Sie die Geschwindigkeits- und Typüberprüfung zur Build- und Laufzeitzeit benötigen, ist diese Hilfsmethode besser als die Verwendung von LINQ, um jedes Element umzuwandeln:

public static T[] GetEnumValues<T>() where T : struct, IComparable, IFormattable, IConvertible
{
    if (typeof(T).BaseType != typeof(Enum))
    {
        throw new ArgumentException(string.Format("{0} is not of type System.Enum", typeof(T)));
    }
    return Enum.GetValues(typeof(T)) as T[];
}

Und Sie können es wie folgt verwenden:

static readonly YourEnum[] _values = GetEnumValues<YourEnum>();

Natürlich können Sie IEnumerable<T> , aber das IEnumerable<T> Ihnen hier nichts.


enum werden "Aufzählungstypen" genannt, nicht weil sie Container sind, die Werte "auflisten" (die sie nicht sind), sondern weil sie durch Auflisten der möglichen Werte für eine Variable dieses Typs definiert werden.

(Eigentlich ist das etwas komplizierter als das - Enum-Typen haben einen "zugrunde liegenden" Integer-Typ, was bedeutet, dass jeder Enum-Wert einem Integer-Wert entspricht (dies ist in der Regel implizit, kann aber manuell angegeben werden). C # wurde entworfen in einer Weise, dass Sie eine beliebige Ganzzahl dieses Typs in die Enum-Variable einfügen können, auch wenn es sich nicht um einen "benannten" Wert handelt.)

Die System.Enum.GetNames-Methode kann verwendet werden, um ein Array von Strings abzurufen, die die Namen der Aufzählungswerte sind, wie der Name schon sagt.

BEARBEITEN: Sollte stattdessen die Methode System.Enum.GetValues vorgeschlagen haben. Hoppla.


foreach (Suit suit in Enum.GetValues(typeof(Suit)))
{
}

(Die derzeit akzeptierte Antwort hat eine Besetzung, von der ich glaube, dass sie nicht benötigt wird (obwohl ich vielleicht falsch liege.)


public void PrintAllSuits()
{
    foreach(string suit in Enum.GetNames(typeof(Suits)))
    {
        Console.WriteLine(suit);
    }
}




enumeration