Перечислены ли перечисления С#?

Ответ 1

Чтобы дать немного другой ответ... в то время как значения являются безопасными по типу с точки зрения кастинга, они все еще не отмечены, как только они были выбраны - i.e.

enum Foo { A = 1, B = 2, C = 3 }    
static void Main()
{
    Foo foo = (Foo)500; // works fine
    Console.WriteLine(foo); // also fine - shows 500
}

По этой причине вы должны позаботиться о проверке значений - например, с помощью default в switch, которая выдает исключение.

Вы также можете проверить (для значений не [Flags]) с помощью:

bool isValid = Enum.IsDefined(typeof(Foo), foo);

Забастовкa >

Ответ 2

Да, они есть.

Ниже приведено http://www.csharp-station.com/Tutorials/Lesson17.aspx

Перечисления - это строго типизированные константы. Они по сути являются уникальными типами, которые позволяют присваивать символические имена целым значениям. В традиции С# они строго типизированы, что означает, что перечисление одного типа не может быть явно не привязано к перечислению другого типа, даже если базовое значение их членов одинаково. Вдоль тех же линий интегральные типы и перечисления не являются неявно взаимозаменяемыми. Все назначения между различными типами перечислений и интегральными типами требуют явного литья.

Ответ 3

Для тех, кто предлагает использовать Enum.IsDefined для проверки правильности аргументов... не надо! Per Brad Abrams (из Обновление руководств по дизайну каркаса в Enum Design):

Есть действительно две проблемы с Enum.IsDefined(). Сначала он загружает отражение и кучу метаданных холодного типа, что делает его обманчиво дорогостоящим вызовом. Во-вторых, как отмечается в примечании, здесь есть проблема с версией.

Ответ 4

Да, они.

Перечисления - это строго типизированные константы. Они по сути являются уникальными типами, которые позволяют назначать символические имена интегральные значения. В традиции С# они строго типизированы, что означает, что перечисление одного типа не может быть неявно присвоенный перечислению другого типа, хотя базовая ценность их членов тоже самое. В то же время, интегральные типы и перечисления не неявно взаимозаменяемы. Все присвоения между различными перечислениями типы и интегральные типы требуют явное приведение.

Ответ 5

Да.

С#: перечисление типов:

-Абезопасное перечисление именованных значений.

- предотвращает ошибки программирования

-User может управлять базовым типом (по умолчанию для int)

- также может управлять базовыми значениями

Ответ 6

Технически нет, потому что вы можете представить Enum в качестве базового значения (int, long и т.д.). Однако, если вы убедитесь, что используете только перечисление по его предоставленным именам, вы получите ошибки времени компиляции, если вы измените имя перечислимого значения без обновления его ссылок. В этом отношении да, это безопасный тип.

Ответ 7

Я опаздываю на вечеринку здесь, но я хотел выбросить что-то еще... Обновление для . от Krzysztof Cwalina. В дополнение к превосходному подсказку выше при проверке того, чтобы действительное значение передавалось в ваш Enums, это дает другие рекомендации и рекомендации относительно того, как их эффективно использовать, кучу gotchas (особенно задействованные перечисления Flags) и т.д.

Ответ 8

да, они сильно набрали безопасный u, не может ли он не прибегнуть к конверсии константных переменных enum в целочисленное значение u hv 2 expilcitly do dat например enum days { солнце, понедельник } int e = (int) days.sun; Console.WriteLine(е);

Ответ 9

Переменные перечисления С# имеют тип безопасного значения

• Вы не можете неявно преобразовать из базового типа в фактическое перечисление
• Кроме того, вы не можете назначить значение одного перечисления другому перечислению, даже если базовые типы обоих перечислений одинаковы. Явное приведение всегда требуется.
• Перечисления делают ваш код более читабельным и более удобным.

Я подошел к отличному видеоуроку по перепискам, которые демонстрируют свой тип безопасного характера. Посмотрите здесь и там.