Есть ли какая-либо значительная разница между использованием если/еще и случаем переключателя в C#?

Мой cs преподаватель предлагал не Вам операторы переключения с тех пор так часто, люди забыли повреждение, или используйте его неправильно. Я могу; t вспоминают точно, что он сказал, но что-то вдоль строк, что рассмотрение некоторой оригинальной кодовой базы, которая показала примеры оператора переключения (несколько лет назад) имело тонны ошибок в нем также.

Вопрос об интересе. Это подошло несколько недель назад на работе, и мы нашли ответ путем записи отрывка в качестве примера, и просматривая ее в Отражателе.NET (отражатель является потрясающим!! я люблю его).

Это - то, что мы обнаружили: допустимый оператор переключения для чего-либо кроме строки компилируется в IL как оператор переключения. Однако, ЕСЛИ это - строка, это переписывается как если/еще если/еще в IL. Таким образом в нашем случае мы хотели знать, как операторы переключения сравнивают строки, например, чувствительно к регистру и т.д., и отражатель быстро дал нам ответ. Это было полезно для знания.

, Если Вы хотите сделать чувствительный к регистру, выдерживают сравнение на строках тогда, Вы могли использовать оператор переключения, поскольку это быстрее, чем выполнение Строки. Сравните в если/еще. (Редактирование: Считайте , Что более быстро, включите строку или elseif на типе? для некоторых фактических тестов производительности) Однако, если Вы хотели сделать нечувствительное к регистру тогда, это лучше использует, если/еще, поскольку получающийся код не симпатичен.

switch (myString.ToLower())
{
  // not a good solution
}

лучшее эмпирическое правило должно использовать операторы переключения, если оно имеет смысл (серьезно), например:

• это улучшает удобочитаемость Вашего кода
• , Вы сравниваете диапазон значений (плавание, интервал) или перечисление

, Если необходимо управлять значением для питания в оператор переключения (создайте временную переменную для переключения против), тогда, вероятно, необходимо использовать, если/еще проверяют утверждение.

обновление:

на самом деле лучше преобразовать строку в верхний регистр (например, ToUpper()), как это было, по-видимому, существует дальнейшая оптимизация, которую своевременный компилятор может сделать как тогда, когда по сравнению с ToLower(). Это - микро оптимизация, однако в жестком цикле, это могло быть полезно.

Немного примечания стороны:

Для улучшения удобочитаемости операторов переключения пробуют следующее:

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

Не только C#, но и все языки на базе С, я думаю: потому что переключатель ограничен константами, возможно генерировать очень эффективный код с помощью "таблицы переходов". Случай C является действительно вычисленным GOTO старого доброго ФОРТРАНА, но случай C# является все еще тестами против константы.

Не то, что оптимизатор будет в состоянии сделать тот же код. Рассмотрите, например,

if(a == 3){ //...
} else if (a == 5 || a == 7){ //...
} else {//...
}

, поскольку те - составные булевские переменные, сгенерированный код должен вычислить значение и короткое замыкание. Теперь рассмотрите эквивалент

switch(a){
   case 3: // ...
    break;
   case 5:
   case 7: //...
    break;
   default: //...
}

, Это может быть скомпилировано в

BTABL: *
B3:   addr of 3 code
B5:
B7:   addr of 5,7 code
      load 0,1 ino reg X based on value
      jump indirect through BTABL+x

, потому что Вы неявно говорите компилятору, что это не должно вычислять ИЛИ и тесты равенства.

Тема стороны, но я часто волнуюсь о (и чаще вижу) if / else и switch, оператор становится слишком большим со слишком многими случаями. Они часто повреждают пригодность для обслуживания.

Общие преступники включают:

1. Выполнение слишком много в нескольких, если операторы
[еще 114] операторы выбора, чем по-человечески возможный проанализировать
3. Слишком много условий в, если оценка для знания, что ищется

Для фиксации:

1. Извлечение к рефакторингу Метода.
2. Использование Словарь с указателями метода вместо случая или использование МОК для добавленной конфигурируемости. Фабрики метода также могут быть полезными.
3. Извлечение условия к их собственному методу

На самом деле оператор переключения более эффективен. Компилятор оптимизирует его к взгляду таблица, где с тем, если/еще операторы это не может. Вниз сторона - то, что оператор переключения не может использоваться со значениями переменных.
Вы не можете сделать:

switch(variable)
{
   case someVariable
   break;
   default:
   break;
}

это должно быть

switch(variable)
{
  case CONSTANT_VALUE;
  break;
  default:
  break;
}

часто это будет выглядеть лучше - т.е. будет легче понять то, что продолжается. Рассмотрение выигрыша в производительности будет чрезвычайно минимально в лучшем случае представление кода является наиболее важным различием.

Так, если, если/еще взгляды лучше, используйте его, иначе используйте оператор переключения.

Компилятор собирается оптимизировать в значительной степени все в тот же код с незначительными различиями (Knuth, кто-либо?).

различие - то, что оператор переключения является более чистым, чем пятнадцать, если еще операторы представили в виде строки вместе.

Друзья не позволяют друзьям сложить если еще операторы.

В целом (рассматривающий все языки и все компиляторы) CAN оператора переключения ИНОГДА еще быть более эффективным, чем, если / оператор, потому что для компилятора легко генерировать таблицы переходов от операторов переключения. Возможно сделать то же самое для того, если / еще операторы, учитывая соответствующие ограничения, но это намного более трудно.

В случае C#, это также верно, но по другим причинам.

С большим количеством строк, существует значительное преимущество производительности для использования оператора переключения, потому что компилятор будет использовать хэш-таблицу для реализации перехода.

С небольшим количеством строк, производительность между этими двумя является тем же.

Это вызвано тем, что в этом случае компилятор C# не генерирует таблицу переходов. Вместо этого это генерирует MSIL, который ЕЩЕ эквивалентен ЕСЛИ / блоки.

существует инструкция по MSIL "оператора переключения" это, когда jitted будет использовать таблицу переходов для реализации оператора переключения. Это только работает с целыми типами, однако (этот вопрос спрашивает о строках).

Для небольших чисел строк, более эффективно для компилятора генерировать, ЕСЛИ / ЕЩЕ блоки тогда это должно использовать хэш-таблицу.

, Когда я первоначально заметил это, я сделал предположение, что, потому что, ЕСЛИ / ЕЩЕ блоки использовались с небольшим количеством строк, что компилятор сделал то же преобразование для больших количеств строк.

Это было НЕПРАВИЛЬНО. 'IMA' был достаточно любезен, чтобы указать на это мне (хорошо..., он не был добр об этом, но он был прав, и я был неправ, который является важной частью)

, я также сделал возглавляемое предположение кости об отсутствии инструкции "по переключателю" в MSIL (я фигурировал, если там действительно ли переключатель был примитивен, почему они не были использующий его с хэш-таблицей, таким образом, не должно быть переключателя, примитивного....). Это было и неправильно, и невероятно глупо с моей стороны. Снова 'IMA' указал на это мне.

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

Однако я сделал его Сообществом Wiki, потому что я полагаю, что не заслуживаю ЧЛЕНА ПАЛАТЫ ПРЕДСТАВИТЕЛЕЙ для того, чтобы быть неправым. Если Вы получаете шанс, голосуете 'за сообщение ima.

Три причины предпочесть switch:

• компилятор А, предназначающийся для собственного кода, может часто компилировать оператор переключения в [1 117] один условный переход плюс косвенный переход , тогда как последовательность if с требует последовательность условных переходов . В зависимости от плотности случаев очень много изученных работ были написаны о том, как скомпилировать операторы выбора эффективно; некоторые связаны от lcc страница компилятора. (Lcc имел один из более инновационных компиляторов для переключателей.)

• оператор переключения А , выбор среди взаимоисключающих альтернатив и синтаксис переключателя делает этот поток управления более очевидным для программиста тогда вложенное множество if-then-else операторов.

• На некоторых языках, включая определенно ML и Haskell, проверки компилятора, чтобы видеть, не учли ли Вы какие-либо случаи . Я просматриваю эту функцию как одно из главных преимуществ ML и Haskell. Я не знаю, может ли C# сделать это.