Bir numaralandırma nasıl numaralandırılır

Nasıl bir enumC # numaralandırmak ?

Örneğin, aşağıdaki kod derlenmez:

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

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

Ve aşağıdaki derleme zamanı hatası verir:

'Suit' bir 'tiptir' ancak 'değişken' gibi kullanılır

Suitİkincisi , anahtar kelimede başarısız olur .

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

Not : Döküm işlemi (Suit[])kesinlikle gerekli değildir, ancak kodu 0,5 ns daha hızlı yapar .

Bana, değerlerden ziyade her bir numaralandırmanın adını yazdırmak istediğiniz gibi görünüyor. Bu durumda Enum.GetNames()doğru yaklaşım gibi görünüyor.

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

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

Bu arada, değeri artırmak, bir numaralandırmanın değerlerini numaralandırmak için iyi bir yol değildir. Bunun yerine bunu yapmalısınız.

Onun Enum.GetValues(typeof(Suit))yerine kullanırdım.

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

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

Kolay numaralandırma kullanımı için bazı uzantılar yaptım. Belki birisi kullanabilir ...

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

Numaralandırmanın kendisi FlagsAttribute ile dekore edilmelidir :

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

.NET çerçevesinin bazı sürümleri desteklenmez Enum.GetValues. Aşağıda , Compact 2.0'daki Fikirler 2.0: Enum.GetValues'dan iyi bir çözüm bulunmaktadır :

public Enum[] GetValues(Enum enumeration)
{
    FieldInfo[] fields = enumeration.GetType().GetFields(BindingFlags.Static | BindingFlags.Public);
    Enum[] enumerations = new Enum[fields.Length];

    for (var i = 0; i < fields.Length; i++)
        enumerations[i] = (Enum) fields[i].GetValue(enumeration);

    return enumerations;
}

Yansıma içeren herhangi bir kodda olduğu gibi, kodun yalnızca bir kez çalıştığından ve sonuçların önbelleğe alındığından emin olmak için adımlar atmalısınız.

Kullanım Cast<T>:

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

İşte böyle IEnumerable<Suit>.

Ben GetValues()her döngü olduğunda çağrılmaz çünkü bu diğer öneriler daha verimli olduğunu düşünüyorum . Aynı zamanda daha özlü. Ve bir derleme zamanı hatası alırsınız, eğer değilse bir çalışma zamanı istisnası Suitdeğil enum.

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

EnumLoop tamamen genel bir tanımı var:

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

Sen almazsınız Enum.GetValues()içinde Silverlight .

Einar Ingebrigtsen tarafından yazılan blog yazısı :

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

Çözümüm .NET Compact Framework'te (3.5) çalışır ve derleme zamanında tür denetimini destekler :

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

• Eğer kimse ondan nasıl kurtulacağını bilirse T valueType = new T(), bir çözüm gördüğüme sevinirim.

Bir çağrı şöyle görünecektir:

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

Bence kullanabilirsiniz

Enum.GetNames(Suit)

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

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

Bunun terifik olarak yavaş olduğuna dair belirsiz söylentiler duydum. Kimse biliyor mu? - Orion Edwards 15 Ekim 08:31 7

Ben dizi önbellekleme önemli ölçüde hızlandıracağını düşünüyorum. Her seferinde yeni bir dizi (yansıma yoluyla) alıyorsunuz gibi görünüyor. Daha doğrusu:

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

Bu en azından biraz daha hızlı, değil mi?

Üç yol:

1. Enum.GetValues(type) // .NET 1.1'den beri Silverlight veya .NET Compact Framework'te değil
2. type.GetEnumValues() // Yalnızca .NET 4 ve üstü sürümlerde
3. type.GetFields().Where(x => x.IsLiteral).Select(x => x.GetValue(null)) // Her yerde çalışır

GetEnumValuesTip örneklerinde neden tanıtıldığından emin değilim . Benim için hiç okunabilir değil.

Enum<T>Benim için en okunaklı ve unutulmaz olanı gibi yardımcı bir sınıfa sahip olmak :

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

Şimdi ara:

Enum<Suit>.GetValues();

// Or
Enum.GetValues(typeof(Suit)); // Pretty consistent style

Performans önemliyse bir tür önbellekleme de kullanılabilir, ancak bunun bir sorun olmasını beklemiyorum.

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

Sadece en iyi cevapları birleştirerek, çok basit bir uzantıyı bir araya getirdim:

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

Temiz, basit ve @ Jeppe-Stig-Nielsen'in yorumuna göre hızlı.

Bir yinelemenin iki yolu vardır Enum:

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

Birincisi size ** object** s dizisi biçiminde değerler verir, ikincisi ise ** String** s dizisi biçiminde değerler verir .

foreachAşağıdaki gibi bir döngüde kullanın :

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

ToString () kullanın sonra bölmek ve tükürük dizisi bayraklar halinde ayrıştırmak.

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

Bunun daha iyi, hatta daha iyi olduğu görüşüne sahip değilim. Sadece bir çözüm daha söylüyorum.

Enum değerleri kesinlikle 0 ila n - 1 arasındaysa, genel bir alternatif:

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

Numaralandırma değerleri bitişikse ve numaralandırmanın ilk ve son öğesini sağlayabiliyorsanız, o zaman:

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

Ama bu kesinlikle numaralandırıcı değil, sadece döngü. İkinci yöntem, diğer yaklaşımlardan çok daha hızlı ...

Derleme ve çalıştırma zamanında hız ve tür denetimine ihtiyacınız varsa, bu yardımcı yöntem her öğeyi yayınlamak için LINQ kullanmaktan daha iyidir:

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[];
}

Ve aşağıdaki gibi kullanabilirsiniz:

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

Tabii ki geri dönebilirsiniz IEnumerable<T>, ama bu size burada hiçbir şey satın almıyor.

Aşağıda, bir DDL için seçim seçenekleri oluşturmanın çalışan bir örneği verilmiştir :

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

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

(Şu anda kabul edilen cevabın gerekli olduğunu düşünmediğim bir oyuncu kadrosu var (her ne kadar yanlış olabilirim).)

Bu soru " C # Adım Adım 2013 " , Bölüm 10'da görünür

Yazar, bir çift Enumerator ile yineleme yapmak için çift bir for-loop kullanır (tam bir kart destesi oluşturmak için):

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

Bu durumda Suitve Valueher ikisi de numaralandırmadır:

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

ve PlayingCardtanımlanmış olan bir kart amacı Suitve Value:

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

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

Biraz dağınık olduğunu biliyorum, ama eğer bir gömlek hayranı iseniz, işte bir:

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

Türün bir olacağını biliyor enum, ancak derleme zamanında tam türün ne olduğunu bilmiyorsanız ne olacak?

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

Yöntem getListOfEnum, herhangi bir enum türünü almak için yansıma kullanır ve IEnumerabletüm enum değerlerinden birini döndürür .

Kullanımı:

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

Bir numaralandırmayı etkileşimde bulunabileceğiniz bir şeye dönüştürmenin basit ve genel bir yolu:

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

Ve sonra:

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

public static IEnumerable<T> GetValues<T>()Sınıfınıza aşağıdaki gibi bir yöntem ekleyin :

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

Numaralandırın. Şimdi kullanarak tekrarlayabilirsiniz foreach:

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

enumtürlere "numaralandırma türleri" denir, çünkü bunlar değerleri "numaralandıran" kapsayıcılar değildirler (değiller), ancak bu türdeki bir değişken için olası değerler numaralandırılarak tanımlanırlar .

(Aslında, bundan biraz daha karmaşıktır - enum türlerinin "temel" bir tamsayı türüne sahip olduğu düşünülür, bu da her bir enum değerinin bir tamsayı değerine karşılık geldiği anlamına gelir (bu genellikle örtüktür, ancak manuel olarak belirtilebilir). Eğer malzeme diye bir biçimde herhangi bir "adında" değeri olmasa bile, enum değişkenine bu tür tamsayı.)

System.Enum.GetNames yöntemi adından da anlaşılacağı gibi, numaralandırma değerleri isimler şeritlerinin bir dizi almak için kullanılabilir.

EDIT: Bunun yerine System.Enum.GetValues yöntemini önermiş olmalıydı . Hata.

Birçok yol denedim ve bu koddan sonuç aldım:

Bir numaradan int listesi almak için aşağıdakileri kullanın. İşe yarıyor!

List<int> listEnumValues = new List<int>();
YourEnumType[] myEnumMembers = (YourEnumType[])Enum.GetValues(typeof(YourEnumType));
foreach ( YourEnumType enumMember in myEnumMembers)
{
    listEnumValues.Add(enumMember.GetHashCode());
}

Ayrıca, yansımayı kullanarak numaralandırmanın genel statik üyelerine doğrudan bağlanabilirsiniz:

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

Eğer varsa:

enum Suit
{
   Spades,
   Hearts,
   Clubs,
   Diamonds
}

Bu:

foreach (var e in Enum.GetValues(typeof(Suit)))
{
    Console.WriteLine(e.ToString() + " = " + (int)e);
}

Çıktı olacak:

Spades = 0
Hearts = 1
Clubs = 2
Diamonds = 3

LINQ Genel Yolu:

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

Kullanımı:

        var enums = ToList<Enum>();