c# zählen wörter - Wie zähle ich eine Aufzählung in C # auf?




13 Answers

foreach (Suit suit in (Suit[]) Enum.GetValues(typeof(Suit)))
{
}
häufigkeiten buchstaben

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 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 denke, das ist effizienter als andere Vorschläge, da GetValues() nicht jedes Mal aufgerufen wird, wenn Sie eine Schleife haben. Es ist auch prägnanter. Sie erhalten einen Fehler bei der Kompilierung und keine Laufzeitausnahme, wenn Suit keine enum .

EnumLoop<Suit>.ForEach((suit) => {
    DoSomethingWith(suit);
});

EnumLoop hat diese vollständig generische Definition:

class EnumLoop<Key> where Key : struct, IConvertible {
    static readonly Key[] arr = (Key[])Enum.GetValues(typeof(Key));
    static internal void ForEach(Action<Key> act) {
        for (int i = 0; i < arr.Length; i++) {
            act(arr[i]);
        }
    }
}



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



Ich denke du kannst verwenden

Enum.GetNames(Suit)



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?




Was zum Teufel werde ich meine zwei Pence einwerfen, indem ich einfach die obersten Antworten kombiniere, entsteht eine sehr einfache Erweiterung

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)
    {
        return (T[])Enum.GetValues(typeof (T));
    }
}

Einfach sauber und durch @ Jeppe-Stig-Nielsens Kommentar schnell.




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
}



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.




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




Ich weiß, dass es ein bisschen chaotisch ist, aber wenn Sie Fans von Einlinern sind, hier ist einer:

((Suit[])Enum.GetValues(typeof(Suit))).ToList().ForEach(i => DoSomething(i));



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



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



Related