Как вы можете перечислить enum в С#?
например. следующий код не компилируется:
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 нс.
Мне кажется, что вы действительно хотите распечатать имена каждого перечисления, а не значения. В этом случае 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;
}
}
Само перечисление должно быть украшено FlagsAttribute
[Flags]
public enum EnumExample
{
ValueA = 1,
ValueB = 2,
ValueC = 4,
ValueD = 8,
Combi = ValueA | ValueB
}
Некоторые версии .NET Framework не поддерживают Enum.GetValues. Вот хороший обходной путь от Ideas 2.0: Enum.GetValues в Compact Framework:
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;
}
Как и в случае любого кода, в котором используется рефлексия, вы должны предпринять шаги, чтобы убедиться, что он выполняется только один раз и результаты кэшируются.
Почему никто не использует 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.
Отправка оригинального сообщения от 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();
}
}
Просто добавьте мое решение, которое работает в компактной структуре (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))) { }Я слышал смутные слухи, что это существенно медленнее. Кто-нибудь знает? - Орион Edwards 15 окт 2008 в 1:31 7
Я думаю, что кеширование массива значительно ускорит его. Похоже, вы каждый раз получаете новый массив (через отражение). Скорее всего:
Array enums = Enum.GetValues(typeof(Suit));
foreach (Suit suitEnum in enums)
{
DoSomething(suitEnum);
}
Это, по крайней мере, немного быстрее, ja?
Три способа:
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
Не знаю, почему было введено 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));
}
}
Очистите просто и быстро с помощью комментария @Jeppe-Stig-Nielsen.
Я использую 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:
1. var values = Enum.GetValues(typeof(myenum))
2. var values = Enum.GetNames(typeof(myenum))
Первый даст вам значения в форме массива object, а второй даст вам значения в виде массива String.
Используйте его в цикле foreach, как показано ниже:
foreach(var value in values)
{
//Do operations here
}
Если значения перечислимого диапазона строго от 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;
}
}
но это не строго перечисление, просто цикл. Второй метод намного быстрее, чем любой другой подход, хотя...
Если вам нужна проверка скорости и типа при сборке и времени выполнения, этот вспомогательный метод лучше, чем использование LINQ для создания каждого элемента:
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>, но вы ничего здесь не покупаете.
вот рабочий пример создания опций выбора для 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()
};
foreach (Suit suit in Enum.GetValues(typeof(Suit)))
{
}
(В текущем принятом ответе есть бросок, который я не думаю (хотя я могу ошибаться).
Этот вопрос появляется в главе 10 "С# Step by Step 2013"
Автор использует двойной цикл for для перебора пары перечислителей (для создания полной колоды карт):
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));
Простой и общий способ преобразования перечисления в нечто, с которым вы можете взаимодействовать:
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>();
Что, если вы знаете, что тип будет 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 использует отражение для ввода любого типа перечисления и возвращает IEnumerable всех значений перечисления.
Использование:
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 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 называются "типами перечисления" не потому, что они являются контейнерами, которые "перечисляют" значения (которые они не являются), а потому, что они определяются путем перечисления возможных значений для переменной этого типа.
(На самом деле, это немного сложнее, чем перечисленные типы enum, как полагают, имеют "базовый" целочисленный тип, что означает, что каждое значение перечисления соответствует целочисленному значению (обычно это неявное, но может быть указано вручную). С# был разработан таким образом, чтобы вы могли вставить любое целое число этого типа в переменную enum, даже если это не "именованное" значение.)
Метод System.Enum.GetNames можно использовать для получения массива строк, которые являются именами значений перечисления, как следует из названия.
РЕДАКТИРОВАТЬ: должен был предложить метод System.Enum.GetValues вместо этого. К сожалению.
Также вы можете привязываться к публичным статическим членам перечисления напрямую, используя отражение:
typeof(Suit).GetMembers(BindingFlags.Public | BindingFlags.Static)
.ToList().ForEach(x => DoSomething(x.Name));
я пробую много способов и получаю результат из этого кода: для получения списка int из перечисления используйте это; это работает!
List<int> listEnumValues = new List<int>();
YourEnumType[] myEnumMembers = (YourEnumType[])Enum.GetValues(typeof(YourEnumType));
foreach ( YourEnumType enumMember in myEnumMembers)
{
listEnumValues.Add(enumMember.GetHashCode());
}
Enum.GetNames(typeof(Suit)).ToList();
не знаю, зачем тебе это нужно. но вы можете сделать как linq:
Enum.GetValues(typeof(Suit))
.Cast<Suit>()
.ToList()
.ForEach(e =>
{
e.GetHashCode().Dump();
e.Dump();
});
Ниже показано перечисление С# (перечисление) с примером.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DemoApplication
{
class Program
{
enum Days{Sun,Mon,tue,Wed,thu,Fri,Sat};
static void Main(string[] args)
{
Console.Write(Days.Sun);
Console.ReadKey();
}
}
}
попробуйте использовать foreach (var item in Enum.GetValues(typeof(Suits)))