එනූමයක් ගණනය කරන්නේ කෙසේද?

enumC # හි ගණනය කිරීමක් කරන්නේ කෙසේද ?

උදා: පහත කේතය සම්පාදනය නොකරයි:

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

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

තවද එය පහත දැක්වෙන සම්පාදක-කාල දෝෂයක් ලබා දෙයි:

'සූට්' යනු 'වර්ගයක්' නමුත් එය 'විචල්යයක්' ලෙස භාවිතා කරයි

එය Suitයතුරු පදයේ අසමත් වේ , දෙවැන්න.

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

සටහන : වාත්තු කිරීම (Suit[])තදින් අවශ්‍ය නොවේ, නමුත් එය 0.5 ns කේතය වේගවත් කරයි.

මට පෙනෙන්නේ ඔබට සාරධර්මවලට වඩා එක් එක් එනූම් වල නම් මුද්‍රණය කිරීමට අවශ්‍ය බවයි. කුමන අවස්ථාවෙහිදී Enum.GetNames()නිවැරදි ප්‍රවේශය ලෙස පෙනේ.

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

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

මාර්ගය වන විට, අගය වැඩි කිරීම එනූමයක අගයන් ගණනය කිරීමට හොඳ ක්‍රමයක් නොවේ. ඒ වෙනුවට ඔබ මෙය කළ යුතුයි.

මම ඒ Enum.GetValues(typeof(Suit))වෙනුවට භාවිතා කරමි .

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

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

පහසුවෙන් එනූම් භාවිතය සඳහා මම දිගු කිහිපයක් කළෙමි. සමහර විට කෙනෙකුට එය භාවිතා කළ හැකිය ...

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

ධජය ධජ ඇට්ට්‍රිබියුට් වලින් සරසා තිබිය යුතුය :

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

.NET රාමුවේ සමහර අනුවාදයන් සහාය නොදක්වයි Enum.GetValues. අයිඩියස් 2.0 වෙතින් හොඳ ක්‍රියාමාර්ගයක් මෙන්න : සංයුක්ත රාමුව තුළ එනම්.ගෙට් අගය :

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

පරාවර්තනය සම්බන්ධ වන ඕනෑම කේතයක් මෙන් , එය එක් වරක් පමණක් ක්‍රියාත්මක වන බව සහතික කිරීමට ඔබ පියවර ගත යුතු අතර ප්‍රති results ල හැඹිලිගත වේ.

භාවිතා කරන්න Cast<T>:

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

ඔන්න යන්න , IEnumerable<Suit>.

අනෙක් යෝජනා වලට වඩා මෙය කාර්යක්ෂම යැයි මම සිතමි, මන්ද GetValues()ඔබ ලූපයක් ඇති සෑම අවස්ථාවකම එය නොකියයි. එය වඩාත් සංක්ෂිප්ත ය. තවද ඔබට සම්පාදක-කාල දෝෂයක් ලැබෙනු Suitඇත enum.

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

EnumLoop මෙම සම්පූර්ණයෙන්ම පොදු අර්ථ දැක්වීමක් ඇත:

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

ඔබ ලබා ගත නොහැකි වේ Enum.GetValues()දී Silverlight .

මුල් බ්ලොග් සටහන අයිනාර් ඉන්ජ්බ්‍රිග්ට්සන් :

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

මගේ විසඳුම .NET සංයුක්ත රාමුව (3.5) තුළ ක්‍රියාත්මක වන අතර සම්පාදනය කරන වේලාවේදී වර්ග පරීක්ෂා කිරීමට සහාය වේ :

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

• එයින් මිදෙන්නේ කෙසේදැයි යමෙක් දන්නේ නම් T valueType = new T(), විසඳුමක් දැකීමට මම සතුටු වෙමි.

ඇමතුමක් මේ වගේ වනු ඇත:

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

මම හිතන්නේ ඔබට භාවිතා කළ හැකිය

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

මෙය ඉතා මන්දගාමී බවට අපැහැදිලි කටකතා මා අසා ඇත. කවුරුහරි දන්නවාද? - ඔරියන් එඩ්වර්ඩ්ස් ඔක්තෝබර් 15 '08 ට 1:31 7

මම හිතන්නේ අරාව හැඹිලියෙන් එය සැලකිය යුතු වේගයකින් වේගවත් වේවි. සෑම විටම ඔබට නව අරාවක් (පරාවර්තනය හරහා) ලැබෙන බව පෙනේ. ඒ වෙනුවට:

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

ඒක අවම වශයෙන් ටිකක් වේගවත් නේද?

ක්‍රම තුනක්:

1. Enum.GetValues(type) .NET 1.1 සිට, සිල්වර් ලයිට් හෝ .NET සංයුක්ත රාමුව තුළ නොවේ
2. type.GetEnumValues() // .NET 4 සහ ඊට ඉහළින් පමණි
3. type.GetFields().Where(x => x.IsLiteral).Select(x => x.GetValue(null)) // සෑම තැනකම වැඩ කරයි

GetEnumValuesවර්ගය අවස්ථා වලදී හඳුන්වා දුන්නේ මන්දැයි මට විශ්වාස නැත . එය මට කිසිසේත් කියවිය නොහැක.

වැනි උපකාරක පංතියක් තිබීම Enum<T>මට වඩාත්ම කියවිය හැකි හා මතක තබා ගත හැකි දෙයකි:

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

දැන් ඔබ අමතන්න:

Enum<Suit>.GetValues();

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

කාර්ය සාධනය වැදගත් නම් යමෙකුට යම් ආකාරයක හැඹිලි භාවිතා කළ හැකිය, නමුත් මෙය කිසිසේත්ම ගැටලුවක් වනු ඇතැයි මම අපේක්ෂා නොකරමි.

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

ඉහළ පිළිතුරු ඒකාබද්ධ කිරීමෙන්, මම ඉතා සරල දිගුවක් එකට විසි කළෙමි:

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

එය පිරිසිදුයි, සරලයි, සහ @ ජෙප්-ස්ටිග්-නීල්සන්ගේ ප්‍රකාශය අනුව, වේගවත්.

නැවත කියවීමට ක්‍රම දෙකක් තිබේ Enum:

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

පළමුවැන්න ඔබට ** object** s අරාවකින් ස්වරූපයෙන් අගයන් ලබා දෙන අතර දෙවැන්න ඔබට ** String** s අරා ආකාරයෙන් අගයන් ලබා දෙනු ඇත .

foreachපහත පරිදි එය ලූපයකින් භාවිතා කරන්න :

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

මම ToString () භාවිතා කර කොඩිවල කෙළ ගසා විග්‍රහ කරමි.

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

මෙය වඩා හොඳ හෝ හොඳ යැයි මම නොසිතමි. මම දැන් කියන්නේ තවත් විසඳුමක්.

Enum අගයන් 0 සිට n - 1 දක්වා පරාසයක පවතී නම්, සාමාන්‍ය විකල්පයක් වන්නේ:

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

එනූම් අගයන් පරස්පර නම් සහ ඔබට එනුම් හි පළමු හා අවසාන අංගය සැපයිය හැකි නම්:

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

නමුත් එය තදින් ගණනය කිරීමක් නොවේ. දෙවන ක්‍රමය වෙනත් ඕනෑම ප්‍රවේශයකට වඩා වේගවත් ය ...

ගොඩනැඟීමේ සහ ධාවනය වන වේලාවේදී ඔබට වේගය සහ ටයිප් කිරීම අවශ්‍ය නම්, එක් එක් මූලද්‍රව්‍යය වාත්තු කිරීම සඳහා ලින්ක් භාවිතා කිරීමට වඩා මෙම සහායක ක්‍රමය වඩා හොඳය:

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

ඔබට එය පහත පරිදි භාවිතා කළ හැකිය:

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

ඇත්ත වශයෙන්ම ඔබට ආපසු යා හැකිය IEnumerable<T>, නමුත් එය ඔබට මෙහි කිසිවක් මිලට නොගනී.

ඩීඩීඑල් සඳහා තෝරාගත් විකල්ප නිර්මාණය කිරීම සඳහා ක්‍රියාකාරී උදාහරණයක් මෙන්න :

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

(දැනට පිළිගත් පිළිතුරට අවශ්‍ය යැයි මා නොසිතන වාත්තු ඇත (මම වැරදියි).)

මෙම ප්‍රශ්නය " C # පියවරෙන් පියවර 2013 " හි 10 වන පරිච්ඡේදයේ දැක්වේ.

කතුවරයා ගණන් ගැනීමේ යුගලයක් හරහා පුනරාවර්තනය කිරීම සඳහා ද්විත්ව ෆෝ-ලූප් භාවිතා කරයි (සම්පූර්ණ කාඩ්පත් තට්ටුවක් නිර්මාණය කිරීමට):

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

මෙම අවස්ථාවේ දී, Suitසහ Valueදෙකම ගණනය කිරීම් වේ:

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

හා PlayingCardඑය අර්ථ සහිත කාඩ් වස්තුවක් Suitහා Value:

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

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

එය ටිකක් අවුල් සහගත බව මම දනිමි, නමුත් ඔබ එක් ලයිනර්වල රසිකයෙක් නම්, මෙන්න එකක්:

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

වර්ගය වර්ගය වනු ඇතැයි enumඔබ දන්නේ නම් කුමක් කළ යුතුද, නමුත් සම්පාදනය කරන වේලාවේ නිශ්චිත වර්ගය කුමක්දැයි ඔබ නොදන්නේද?

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

මෙම ක්‍රමය getListOfEnumඕනෑම enum වර්ගයක් ගැනීමට පරාවර්තනය භාවිතා කර aIEnumerable අතර සියලු enum අගයන්ගෙන් එකක් ලබා දෙයි.

භාවිතය:

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

ඔබට අන්තර්ක්‍රියා කළ හැකි දෙයකට එනූමයක් පරිවර්තනය කිරීම සඳහා සරල හා සාමාන්‍ය ක්‍රමයක්:

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

ඊළගට:

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

public static IEnumerable<T> GetValues<T>()ඔබේ පන්තියට ක්‍රමයක් එක් කරන්න , වැනි:

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

ඔබේ එනූම් අමතන්න. දැන් ඔබට එය භාවිතයෙන් නැවත කියවිය හැකිය foreach:

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

enumවර්ග "ගණන් කිරීමේ වර්ග" ලෙස හඳුන්වන්නේ ඒවා "ගණනය කරන" අගයන් (ඒවා නොවන) බහාලුම් නිසා නොව, ඒවා අර්ථ දැක්වෙන්නේ එම වර්ගයේ විචල්‍යයක් සඳහා විය හැකි අගයන් ගණනය කිරීමෙනි .

. ඔබට ඕනෑම දෙයක් පුරවා ගත හැකි වන පරිදි , නිඛිල විචල්ය බවට එම වර්ගයේ පූර්ණ සංඛ්යාමය එය "නම්" අගය නොවේ පවා නම්.)

මෙම System.Enum.GetNames ක්රමය නමින් හැඟී ලෙස, නිඛිල වටිනාකම් නම් වන නූල් රැසක් ලබා ගැනීමට භාවිතා කළ හැක.

සංස්කරණය කරන්න: ඒ වෙනුවට System.Enum.GetValues ක්‍රමය යෝජනා කළ යුතුව තිබුණි . අපොයි.

මම බොහෝ ක්‍රම අත්හදා බැලූ අතර මෙම කේතයෙන් ප්‍රති result ලය ලැබුණි:

Enum වෙතින් int ලැයිස්තුවක් ලබා ගැනීම සඳහා, පහත සඳහන් දෑ භාවිතා කරන්න. එය වැඩ කරනවා!

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

පරාවර්තනය භාවිතා කිරීමෙන් ඔබට සෘජුවම එනූම් හි පොදු ස්ථිතික සාමාජිකයන් සමඟ බැඳිය හැකිය:

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

ඔබට තිබේ නම්:

enum Suit
{
   Spades,
   Hearts,
   Clubs,
   Diamonds
}

මෙය:

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

ප්‍රතිදානය කරයි:

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

ලින්ක් සාමාන්‍ය මාර්ගය:

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

භාවිතය:

        var enums = ToList<Enum>();