Перечисления C # безопасны?

Question

Безопасны ли перечисления C #?

Если нет, каковы последствия?

Answer 1

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

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

Answer 2

Да, они есть.

Следующее от http://www.csharp -station.com / Tutorials / Lesson17.aspx

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

Answer 3

Для тех, кто предлагает использовать Enum.IsDefined для проверки аргументов ... не надо! Пер Брэд Абрамс (из обновления Руководства по разработке структуры Enum Design ):

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

Answer 4

C # перечисления являются типом безопасного значения

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

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

Answer 5

да, они строго типизированы, защищены, вы не можете, это не делает неконтролируемое преобразование постоянных переменных перечисления в целочисленное значение. например enum days { солнце, понедельник } int e = (int) days.sun; Console.WriteLine (е);

Answer 6

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

Answer 7

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

Answer 8

Да.

C #: типы перечислений:

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

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

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

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

Answer 9

Да, они .

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