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




13 Answers

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());
    }
}
wörter häufigkeiten von

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.




Einige Versionen von .NET Framework unterstützen Enum.GetValues . Hier ist eine gute Lösung für Ideas 2.0: Enum.GetValues ​​in Compact Framework :

public List<Enum> GetValues(Enum enumeration)
{
   List<Enum> enumerations = new List<Enum>();
   foreach (FieldInfo fieldInfo in enumeration.GetType().GetFields(
         BindingFlags.Static | BindingFlags.Public))
   {
      enumerations.Add((Enum)fieldInfo.GetValue(enumeration));
   }
   return enumerations;
}

Wie bei jedem Code, der reflection , sollten Sie sicherstellen, dass er nur einmal ausgeführt wird und die Ergebnisse zwischengespeichert werden.




Warum verwendet niemand Cast<T> ?

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

Da gehst du IEnumerable<Suit> .




Um meine Lösung hinzuzufügen, die im kompakten Framework (3.5) arbeitet und die Typüberprüfung zur Kompilierzeit unterstützt :

public static List<T> GetEnumValues<T>() where T : new() {
    T valueType = new T();
    return typeof(T).GetFields()
        .Select(fieldInfo => (T)fieldInfo.GetValue(valueType))
        .Distinct()
        .ToList();
}

public static List<String> GetEnumNames<T>() {
    return typeof (T).GetFields()
        .Select(info => info.Name)
        .Distinct()
        .ToList();
}

- Wenn jemand weiß, wie man T valueType = new T() loswird, würde ich mich über eine Lösung freuen.

Ein Anruf würde so aussehen:

List<MyEnum> result = Utils.GetEnumValues<MyEnum>();



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



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



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



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




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



Diese Frage erscheint in Kapitel 10 von " C # Step by Step 2013 ".

Der Autor verwendet eine doppelte for-Schleife, um ein Paar Enumeratoren zu durchlaufen (um ein volles Kartendeck zu erstellen):

class Pack
{
    public const int NumSuits = 4;
    public const int CardsPerSuit = 13;
    private PlayingCard[,] cardPack;

    public Pack()
    {
        this.cardPack = new PlayingCard[NumSuits, CardsPerSuit];
        for (Suit suit = Suit.Clubs; suit <= Suit.Spades; suit++)
        {
            for (Value value = Value.Two; value <= Value.Ace; value++)
            {
                cardPack[(int)suit, (int)value] = new PlayingCard(suit, value);
            }
        }
    }
}

In diesem Fall sind Suit und Value beide Aufzählungen:

enum Suit { Clubs, Diamonds, Hearts, Spades }
enum Value { Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace}

und PlayingCard ist ein PlayingCard mit einem definierten Suit und Value :

class PlayingCard
{
    private readonly Suit suit;
    private readonly Value value;

    public PlayingCard(Suit s, Value v)
    {
        this.suit = s;
        this.value = v;
    }
}



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



Fügen Sie der Klasse public static IEnumerable<T> GetValues<T>() Ihrer Klasse hinzu, wie

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

call und pass dein enum, jetzt kannst du es mit foreach durchlaufen

 public static void EnumerateAllSuitsDemoMethod()
 {
     // custom method
     var foos = GetValues<Suit>(); 
     foreach (var foo in foos)
     {
         // Do something
     }
 }



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.






Related