Каков предпочтительный метод для обработки неожиданных перечислимых значений?

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

корректный ответ, Вы очень редко переключаетесь в язык OO, он указывает на выполнение OO неправильно. В этом случае это - идеальный признак, что Ваш Класс Enum имеет проблемы.

необходимо просто называть Консоль. WriteLine (mood.moodMessage ()), и определяющий moodMessage для каждого из состояний.

, Если новое состояние добавляется - Весь Ваш Код Должен Адаптироваться Автоматически, ничто не должно приводить к сбою, выдавать изменения потребности или исключение.

Редактирование: ответ на комментарий.

В Вашем примере, чтобы быть "Хорошим OO" функциональностью режима файла управлял бы объект FileMode. Это могло содержать объект делегата с "открытым, считать, записать..." операции, которые отличаются для каждого FileMode, таким образом, File.open ("имя", FileMode. Создайте), мог быть реализован как (извините об отсутствии знакомства с API):

open(String name, FileMode mode) {
    // May throw an exception if, for instance, mode is Open and file doesn't exist
    // May also create the file depending on Mode
    FileHandle fh = mode.getHandle(name);
    ... code to actually open fh here...
    // Let Truncate and append do their special handling
    mode.setPosition(fh);
}

Это намного более опрятно, чем попытка сделать это с переключателями... (между прочим, методы были бы и частными на пакет и возможно делегированные к классам "Режима")

, Когда OO преуспевается, каждый метод похож на несколько строк действительно понятного, простого кода - СЛИШКОМ простой. Вы всегда получаете чувство, что существует некоторое большое грязное "Ядро Сыра", скрепляющее все небольшие объекты начо, но Вы никогда не можете находить его - это - начо полностью вниз...

Я обычно пытаюсь определить неопределенное значение (0):

enum Mood { Undefined = 0, Happy, Sad }

Тот путь я могу всегда говорить:

switch (mood)
{
    case Happy: Console.WriteLine("I am happy"); break;
    case Sad:   Console.WriteLine("I am sad"); break;
    case Undefined: // handle undefined case
    default: // at this point it is obvious that there is an unknown problem
             // -> throw -> die :-)
}

Это, по крайней мере, как я обычно делаю это.

Это - обязанность функции вызова обеспечить допустимый вход и implicitely, что-либо не в перечислении недопустимо (Прагматически настроенный программист, кажется, подразумевает это). Тем не менее это подразумевает, что любое время, Вы изменяете свое перечисление, необходимо изменить ВЕСЬ код, который принимает его как вход (и НЕКОТОРЫЙ код, который приводит к нему, как произведено). Но это, вероятно, верно так или иначе. Если у Вас есть перечисление, которое часто изменяется, вероятно, необходимо использовать что-то другое, чем перечисление, полагая, что перечисления обычно являются объектами времени компиляции.

Назовите это мнением или предпочтением, но идея позади перечисления состоит в том, что это представляет полный список возможных значений. Если "неожиданное значение" раздается в коде, то перечисление (или цель позади перечисления) не актуально. Мое персональное предпочтение то, что каждый перечислимый перенос присвоение по умолчанию Неопределенных. Учитывая, что перечисление является определенным списком, это никогда не должно быть устаревшим с Вашим кодом потребления.

До того, что сделать, если Ваша функция получает или неожиданное значение или Неопределенная в моем случае, универсальный ответ не кажется возможным. Для меня это зависит от контекста причины оценки перечисления значений: действительно ли это - ситуация, где выполнение кода должно остановиться, или значение по умолчанию может использоваться?

У Вас могла быть трассировка для значения по умолчанию, вызывающего значение переданного перечисления. Выдавание исключения в порядке, но в крупном приложении будет несколько мест, где Ваш код не заботится о других значениях перечисления.
Так, если Вы не уверены, что код намеревается обработать все возможные значения перечисления, необходимо будет возвратиться позже и удалить исключение.

Для C# что-то стоящее знать - то, что Enum.IsDefined() опасен . Вы не можете полагаться на него как Вы. Получение чего-то не математических ожиданий является хорошим случаем для выдачи исключения и смерти громко.

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

Это - один из тех вопросов, который доказывает, почему разработка через тестирование так важна.

В этом случае я пошел бы для NotSupportedException, потому что буквально значение было не обработано и поэтому не поддерживаемое. NotImplementedException дает больше идею: "Это еще не закончено";)

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

Корректный ответ программы был бы к , умирают способом, который позволит разработчику легко определять проблему. mmyers и JaredPar оба дал хорошие способы сделать это.

, Почему умирают? , Который кажется столь экстремальным!

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

кроме того, если программа умирает, существует намного больший шанс, что Вы собираетесь поймать ее в QA, и таким образом она даже не идет наружу.

Мое мнение то, что, так как это - ошибка программиста, которую необходимо или утверждать на нем или бросить RuntimException (Java, или независимо от того, что эквивалент для других языков). У меня есть свой собственный UnhandledEnumException, который расширяется от RuntimeException, который я использую для этого.

В Java стандартный путь состоит в том, чтобы бросить AssertionError по двум причинам:

1. Это гарантирует, что, даже если asserts отключены, ошибка брошена.
2. Вы утверждаете, что нет никаких других перечислимых значений, таким образом AssertionError документы Ваши предположения лучше, чем NotImplementedException (который Java не имеет так или иначе).

Для в значительной степени каждого оператора переключения в моей кодовой базе у меня есть следующий случай по умолчанию

switch( value ) { 
...
default:
  Contract.InvalidEnumValue(value);
}

, метод выдаст исключение, детализирующее значение перечисления в точке, ошибка была обнаружена.

public static void InvalidEnumValue<T>(T value) where T: struct
{
    ThrowIfFalse(typeof(T).IsEnum, "Expected an enum type");
    Violation("Invalid Enum value of Type {0} : {1}", new object[] { typeof(T).Name, value });
}