Kaip įtraukti sąrašą C #?

Kaip galite įrašyti „ enum į „C #“?

Pavyzdžiui. Šis kodas nesudaro:

19 сент. Ian Boyd nustatė rugsėjo 19 d 2008-09-19 23:34 '08 at 23:34 pm 2008-09-19 23:34
@ 26 atsakymai
 foreach (Suit suit in (Suit[]) Enum.GetValues(typeof(Suit))) { } 

Pastaba : liejimas į (Suit[]) nėra būtinas, tačiau kodą galima greičiau padaryti 0,5 ns.

4117
19 сент. atsakymas pateiktas 19 d 2008-09-19 23:37 '08 at 23:37 pm 2008-09-19 23:37

Man atrodo, kad jūs tikrai norite išspausdinti kiekvieno sąrašo pavadinimus, o ne vertybes. Šiuo atveju „ Enum.GetNames() atrodo teisingas.

 public enum Suits { Spades, Hearts, Clubs, Diamonds, NumSuits } public void PrintAllSuits() { foreach (string name in Enum.GetNames(typeof(Suits))) { System.Console.WriteLine(name); } } 

Beje, vertės didinimas nėra geras būdas įrašyti enum vertes. Turėtumėte tai padaryti.

border=0

Vietoj to, norėčiau naudoti „ 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()); } } 
606
19 сент. atsakymas duotas Haacked rugsėjo 19 d 2008-09-19 23:39 '08 at 11:39 2008-09-19 23:39

Aš padariau keletą plėtinių paprastam naudojimui, gal kas nors gali jį naudoti ...

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

Sąrašą reikia papuošti „ FlagsAttribute“

 [Flags] public enum EnumExample { ValueA = 1, ValueB = 2, ValueC = 4, ValueD = 8, Combi = ValueA | ValueB } 
300
03 июня '09 в 15:03 2009-06-03 15:03 atsakymas pateikiamas bob birželio 03, 09 d. 15:03 2009-06-03 15:03

Kai kurios .NET platformos versijos nepalaiko Enum.GetValues . Toliau pateikiamas geras sprendimas „ Idea 2.0“: „Enum.GetValues“ kompaktiškoje sistemoje :

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

Kaip ir bet kuris kodas, kuriame yra atspindys , turite imtis veiksmų, kad įsitikintumėte, jog jis veikia tik vieną kartą, o rezultatai išsaugomi talpykloje.

156
03 сент. Atsakymą pateikė Ekevoo 03 rugsėjis. 2009-09-03 21:48 '09 at 9:48 PM 2009-09-03 21:48

Manau, kad tai yra efektyvesnis už kitus pasiūlymus, nes „ GetValues() nėra vadinamas kiekvieną kartą, kai turite kilpą. Jis taip pat yra iškalbingesnis. Ir gausite kompiliavimo laiko klaidą, o ne paleisties laiką, jei „ Suit nėra enum .

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

EnumLoop turi šį visiškai bendrą apibrėžimą:

 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]); } } } 
90
02 февр. Atsakymą pateikė James 02 Feb. 2012-02-02 16:36 '12 at 4:36 pm 2012-02-02 16:36

Kodėl niekas nenaudoja „ Cast<T> ?

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

Ten einate IEnumerable<Suit> .

89
17 марта '13 в 7:15 2013-03-17 07:15 atsakymas pateikiamas sircodesalot, kovo 17 d., 13 val., 2013-03-17 07:15

Enum.GetValues() nebus Enum.GetValues() „Silverlight“.

Originalios žinutės siuntimas iš 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(); } } 
71
17 нояб. Atsakymą pateikė Aubrey Taylor lapkričio 17 d. 2010-11-17 04:29 '10, 4:29, 2010-11-17 04:29

Tiesiog pridėkite mano sprendimą, kuris veikia kompaktiškoje struktūroje (3.5) ir palaiko tipo tikrinimą kompiliavimo metu :

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

- Jei kas nors žino, kaip atsikratyti T valueType = new T() , norėčiau pamatyti sprendimą.

Šis skambutis atrodys taip:

 List<MyEnum> result = Utils.GetEnumValues<MyEnum>(); 
53
07 июля '10 в 16:37 2010-07-07 16:37 atsakymas pateikiamas „ Mallox “ liepos 7 d. 10 d. 4:37 2010-07-07 16:37

Manau, galite naudoti

 Enum.GetNames(Suit) 
48
19 сент. Atsakyti Tom Carr Sep 19 2008-09-19 23:37 '08 at 23:37 pm 2008-09-19 23:37
 public void PrintAllSuits() { foreach(string suit in Enum.GetNames(typeof(Suits))) { Console.WriteLine(suit); } } 
44
20 сент. Joshua Drake atsakymas, pateiktas rugsėjo 20 d. 2008-09-20 00:05 '08 0:05 2008-09-20 00:05
 foreach (Suit suit in Enum.GetValues(typeof(Suit))) { } 

Girdėjau neaiškius gandus, kad tai yra žymiai lėčiau. Ar kas nors žino? - Orion Edwards 2008 m. Spalio 15 d., 1:31 val

Manau, kad masyvo talpinimas sparčiai pagreitins. Atrodo, kad kiekvieną kartą, kai gaunate naują masyvą (per atspindį). Labiausiai tikėtina:

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

Ar tai bent šiek tiek greičiau, ja?

41
16 нояб. Atsakymas pateiktas „ Limited Atonement“ lapkričio 16 d. 2009-11-16 20:19 '09, 20:19, 2009-11-16 20:19

Trys būdai:

 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 

Nežinau, kodėl „ GetEnumValues buvo įvestas tokio tipo pavyzdžiu, tai man visiškai neįskaitoma.


Pagalbinės klasės, pvz., „ Enum<T> , Enum<T> yra labiausiai skaitomas ir įsimintinas man:

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

Dabar skambinate:

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

Taip pat galite naudoti talpyklą, jei tai yra susiję su našumu, tačiau tikiuosi, kad tai visai nebus problema

 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))); } } 
24
12 авг. atsakymas pateikiamas nawfal 12 rug . 2013-08-12 18:36 '13, 18:36, 2013-08-12 18:36

Ką pragaras, aš atsisakysiu savo dviejų pensų, tiesiog derindamas geriausius atsakymus, kuriuos aš sujungiau, labai paprastą pratęsimą

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

Išvalykite paprastą ir greitą komentarą @ Jeppe-Stig-Nielsen.

22
15 июня '13 в 11:22 2013-06-15 11:22 atsakymą pateikė Darkside, birželio 15 d., 13 val., 11:22, 2013-06-15 11:22

Aš naudoju „ToString“ (), tada padalijau ir analizuoju viršūnių masyvą vėliavose.

 [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); } 
21
26 июля '12 в 12:22 2012-07-26 12:22 atsakymą Mickey Perlstein pateikė liepos 26 d. 12 val. 12:22 2012-07-26 12:22

Yra du būdai Enum kartoti:

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

Pirmieji suteiks jums reikšmes object masyvo pavidalu, o antrasis suteiks jums vertes masyvo String forma.

Naudokite jį foreach , kaip parodyta žemiau:

 foreach(var value in values) { //Do operations here } 
21
22 янв. Atsakymas suteiktas Kylo Ren 22 saus 2016-01-22 21:50 '16 at 9:50 pm 2016-01-22 21:50

Jei kurdami ir vykdydami reikia patikrinti greitį ir tipą, šis pagalbininko metodas yra geresnis už LINQ kūrimą kiekvienam elementui sukurti:

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

Ir galite jį naudoti taip:

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

Žinoma, galite grąžinti „ IEnumerable<T> , bet čia nieko neperkate.

15
15 нояб. atsakymas yra dmihailescu lapkričio 15 d. 2013-11-15 23:13 '13, 23:13 2013-11-15 23:13

Nemanau, kad tai yra geresnė ar net gera, tiesiog nurodant dar vieną sprendimą.

Jei išvardinto diapazono vertės yra griežtai nuo 0 iki n-1, tuomet bendra alternatyva yra:

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

Jei skaičiavimo vertės yra gretimos ir galite pateikti pirmąjį ir paskutinį sąrašo elementą, tada:

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

bet tai nėra griežtai įtraukta, tik kilpa. Antrasis metodas yra daug greitesnis nei bet kuris kitas metodas, nors ...

15
25 янв. Atsakymas pateikiamas nawfal Jan 25 2013-01-25 03:05 '13, 03:05 2013-01-25 03:05

Čia pateikiamas darbo DDL pasirinkimo parinkčių kūrimo pavyzdys

 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() }; 
12
26 окт. atsakymas duotas jhilden 26 sp 2012-10-26 00:20 '12 - 0:20 2012-10-26 00:20
 foreach (Suit suit in Enum.GetValues(typeof(Suit))) { } 

(Dabartiniame priimtame atsakyme yra mąstymas, kurį nemanau (nors aš galiu klysti).

10
20 янв. atsakymas į matinį deginimą sausio 20 d 2014-01-20 13:37 '14, 13:37 2014-01-20 13:37

Šis klausimas pateikiamas 10 skyriuje „ 2013 m

Autorius naudoja dvigubą kilpą, kad pasikartotų per skaitiklių porą (jei norite sukurti visą kortelių paketą):

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

Tokiu atveju Suit ir Value yra abu sąrašai:

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

ir „ PlayingCard - tai kortelės objektas su apibrėžtu Suit ir Value :

 class PlayingCard { private readonly Suit suit; private readonly Value value; public PlayingCard(Suit s, Value v) { this.suit = s; this.value = v; } } 
9
28 июня '15 в 9:12 2015-06-28 09:12 atsakymą pateikė Ross Gatih birželio 28 d. 15 val. 9:12 2015-06-28 09:12

Paprastas ir bendras būdas konvertuoti sąrašą į kažką, su kuriuo galite bendrauti:

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

Ir tada:

 var enums = EnumHelper.ToList<MyEnum>(); 
7
12 сент. atsakymas, kurį pateikė Gabriel Sep 12 2014-09-12 21:06 '14, 21:06 2014-09-12 21:06

Žinau, kad tai šiek tiek nepatogus, bet jei esate vienos linijos gerbėjas, čia yra vienas iš jų:

 ((Suit[])Enum.GetValues(typeof(Suit))).ToList().ForEach(i => DoSomething(i)); 
7
08 апр. atsakymą pateikė anar khalilov 08 balandžio. 2014-04-08 18:44 '14 at 18:44 2014-04-08 18:44

Ką daryti, jei žinote, kad tipas bus enum , bet jūs nežinote, kokio tipo yra tiksliai kompiliavimo metu?

 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 metodas naudoja atspindį, kad įvestų bet kokio tipo skaičiavimus, ir grąžina IEnumerable visų skaičiavimo reikšmių.

Naudoti:

 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)); } 
6
01 окт. atsakymas duotas Slappywag Oct 01 2015-10-01 13:14 '15, 13:14 pm 2015-10-01 13:14

Pavyzdžiui, pridėkite public static IEnumerable<T> GetValues<T>() metodą

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

skambinkite ir perkelkite savo sąrašą, dabar galite jį pakartoti naudojant foreach

  public static void EnumerateAllSuitsDemoMethod() { // custom method var foos = GetValues<Suit>(); foreach (var foo in foos) { // Do something } } 
3
31 марта '17 в 10:08 2017-03-31 10:08 Atsakymas duotas MUT kovo 31 d. 17 val. 10:08 2017-03-31 10:08

enum tipai vadinami „skaičiavimo tipais“ ne todėl, kad jie yra talpyklos, kuriose „skaičiuojamos“ reikšmės (kurios jos nėra), bet todėl, kad jos yra apibrėžtos išvardinant galimus tokio tipo kintamojo dydžius.

(Tiesą sakant, tai yra šiek tiek sudėtingesnė, nei manoma, kad išvardyti enum tipai turi „pagrindinį“ sveikojo skaičiaus tipą, o tai reiškia, kad kiekviena enum vertė atitinka sveikojo skaičiaus reikšmę (paprastai ji yra netiesioginė, bet gali būti nustatyta rankiniu būdu). taip, kad galėtumėte įterpti bet kokį tokio tipo sveikąjį skaičių į „Enum“ kintamąjį, net jei jis nėra „pavadintas“ reikšmė.

Sistemos „ System.Enum.GetNames“ metodas gali būti naudojamas tam, kad gautų eilutes, kurios yra vardų reikšmių pavadinimai, kaip rodo pavadinimas.

EDIT: vietoj to turėjo būti pasiūlytas metodas System.Enum.GetValues . Atsiprašome.

0
11 окт. Emily Chen atsakymas, pateiktas spalio 11 d 2017-10-11 07:50 '17 at 7:50 2017-10-11 07:50

Taip pat galite susieti su viešaisiais statinio sąrašo nariais, tiesiogiai naudodami atspindį:

 typeof(Suit).GetMembers(BindingFlags.Public | BindingFlags.Static) .ToList().ForEach(x => DoSomething(x.Name)); 
0
10 янв. atsakymas yra Termininja 10 sausis 2017-01-10 02:39 '17 at 2:39 2017-01-10 02:39

Kiti klausimai apie žymes arba Užduoti klausimą