Чи є якась істотна різниця між використанням if / else та регістром перемикання в C #?

Яка вигода / мінус у використанні switchоператора порівняно із знаком if/elseу C #. Я не можу уявити, що існує така велика різниця, крім, мабуть, вигляду вашого коду.

Чи є якась причина, чому результуюча ІЛ або пов'язана з цим продуктивність виконання кардинально відрізнятиметься?

Пов’язано: Що швидше, увімкніть рядок або інший тип?

Оператор SWITCH виробляє лише таку ж збірку, що і IF в режимі налагодження або сумісності. У випуску вона буде складена у таблицю стрибків (через оператор MSIL 'switch') - що є O (1).

C # (на відміну від багатьох інших мов) також дозволяє вмикати струнні константи - і це працює трохи інакше. Очевидно, що не можна будувати таблиці стрибків для рядків довільної довжини, тому найчастіше такий комутатор буде зібраний у стек IF.

Але якщо кількість умов достатньо велика для покриття накладних витрат, компілятор C # створить об'єкт HashTable, заповнить його рядковими константами і зробить пошук на цій таблиці з подальшим стрибком. Пошук хешбета не є строго O (1) і має помітні постійні витрати, але якщо кількість міток регістру велика, це буде значно швидше, ніж порівняння з кожною рядковою константою в ІФ.

Підсумовуючи це, якщо кількість умов більше 5 або більше, віддайте перевагу SWITCH над IF, інакше використовуйте все, що виглядає краще.

Загалом (з огляду на всі мови та всі компілятори) оператор перемикача CAN SOMETIMES може бути більш ефективним, ніж оператор if / else, оскільки компілятору легко генерувати таблиці стрибків з операторів перемикання. Можна зробити те ж саме і для операторів if / else з відповідними обмеженнями, але це набагато складніше.

У випадку з C # це теж правда, але з інших причин.

З великою кількістю рядків є значна перевага в продуктивності використання оператора switch, оскільки компілятор буде використовувати хеш-таблицю для здійснення стрибка.

З невеликою кількістю струн продуктивність між ними однакова.

Це тому, що в такому випадку компілятор C # не генерує таблицю стрибків. Натомість він генерує MSIL, що еквівалентно блокам IF / ELSE.

Існує інструкція MSIL "твердження про перемикання", що при натисканні буде використовувати таблицю стрибків для реалізації оператора перемикання. Однак він працює лише з цілими типами (це питання задає рядки).

Для невеликої кількості рядків компілятору ефективніше генерувати блоки IF / ELSE, тож використовувати хеш-таблицю.

Коли я спочатку помітив це, я зробив припущення, що оскільки блоки IF / ELSE використовуються з невеликою кількістю рядків, компілятор здійснив те саме перетворення для великої кількості рядків.

Це було НЕПРАВНО. "IMA" був досить люб'язний, щоб вказати на це мені (ну ... він був недобрий до цього, але він мав рацію, і я помилявся, що важлива частина)

Я також висловив припущення про відсутність інструкції "перемикання" в MSIL (я зрозумів, якщо там був примітив комутатора, чому вони не використовували його з хеш-таблицею, тому не повинно бути примітиву перемикача. ...). Це було як неправильно, так і неймовірно нерозумно з мого боку. Знову "IMA" вказав на це мені.

Я зробив тут оновлення, оскільки це найвищий рейтинг і прийнята відповідь.

Однак я зробив це Community Wiki, тому що вважаю, що я не заслуговую на те, щоб REP не помилявся. Якщо ви отримаєте шанс, будь ласка, проголосуйте за повідомлення 'ima'.

Три причини віддати перевагу switch:

• Компілятор, націлений на власний код, часто може компілювати оператор перемикання в одну умовну гілку плюс непрямий стрибок, тоді як послідовність ifs вимагає послідовності умовних гілок . Залежно від щільності випадків було написано багато наукових праць про те, як ефективно складати виписки з справ; деякі з них пов’язані зі сторінки компілятора lcc . (У Lcc був один з більш інноваційних компіляторів для комутаторів.)

• Оператор перемикання - це вибір між взаємовиключними альтернативами, і синтаксис комутатора робить цей потік управління більш прозорим для програміста, ніж гніздо операторів if-then-else.

• У деяких мовах, включаючи, безумовно, ML та Haskell, компілятор перевіряє, чи не залишили ви жодних справ . Я розглядаю цю особливість як одну з головних переваг ML та Haskell. Я не знаю, чи може це зробити C #.

Анекдот: на лекції, яку він читав, коли отримував нагороду за все життя, я чув, як Тоні Хоар говорив, що з усіх речей, які він робив у своїй кар'єрі, було три, якими він найбільше пишався:

• Винахідництво Quicksort
• Винайдення оператора перемикання (який Тоні назвав caseоператором)
• Починаючи і закінчуючи свою кар’єру в галузі

Я не уявляю, як житиswitch .

Компілятор майже все оптимізує в той же код з незначними відмінностями (Knuth, хтось?).

Різниця полягає в тому, що оператор переключення чистіший, ніж п’ятнадцять, якщо інші операції з'єднані разом.

Друзі не дозволяють друзям складати заяви, якщо інше.

Насправді оператор перемикання є більш ефективним. Компілятор оптимізує його до таблиці пошуку, де з операторами if / else він не може. Суть в тому, що оператор перемикання не може використовуватися зі змінними значеннями.
Ви не можете:

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

це має бути

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

Я не бачив, щоб хто-небудь інший піднімав (очевидно?) Пункт про те, що передбачувана перевага ефективності оператора перемикання залежить від того, що різні випадки є приблизно однаковою. У випадках, коли одне (або декілька) значень набагато вірогідніше, сходова клітка може бути набагато швидшою, забезпечивши перевірку найбільш поширених випадків:

Так, наприклад:

if (x==0) then {
  // do one thing
} else if (x==1) {
  // do the other thing
} else if (x==2) {
  // do the third thing
}

проти

switch(x) {
  case 0: 
         // do one thing
         break;
  case 1: 
         // do the other thing
         break;
  case 2: 
         // do the third thing
         break;
}

Якщо x дорівнює 90% часу, код "if-else" може бути вдвічі швидшим, ніж код на основі комутатора. Навіть якщо компілятор перетворить "перемикач" на якусь розумну керовану таблицю goto, він все одно не буде настільки швидким, як проста перевірка нуля.

часто це буде виглядати краще - тобто буде легше зрозуміти, що відбувається. Зважаючи на те, що вигода від продуктивності буде в кращому випадку мінімальною, перегляд коду є найважливішою відмінністю.

Отже, якщо якщо / else виглядає краще, використовуйте його, інакше використовуйте оператор перемикання.

Побічна тема, але я часто хвилююсь (і частіше бачу) if/ elseі switchтвердження стає занадто великим із занадто великою кількістю справ. Вони часто шкодять ремонту.

До поширених винуватців належать:

1. Занадто багато всередині кількох, якщо висловлювань
2. Більше тверджень про випадки, ніж по-людськи, можливо проаналізувати
3. Занадто багато умов в оцінці if, щоб знати, що шукають

Виправити:

1. Екстракт до методу рефакторингу.
2. Використовуйте словник з покажчиками методів замість регістру або використовуйте IoC для додаткової налаштування. Фабрики методів також можуть бути корисними.
3. Витягніть умови власним методом

Відповідно до цього посилання, ІФ порівняно з переключенням тестування ітерації за допомогою перемикача, і якщо оператор, як для 1 000 000 000 ітерацій, час, взятий за допомогою вимикача = 43,0 с і за умови виписки = 48,0 с

Це буквально 20833333 ітерації в секунду. Отже, чи нам справді потрібно більше зосередитися,

PS: Просто знати різницю продуктивності для невеликого переліку умов.

Якщо ви просто використовуєте, якщо або інше твердження, базове рішення використовує порівняння? оператор

(value == value1) ? (type1)do this : (type1)or do this;

Ви можете виконати або рутину в комутаторі

switch(typeCode)
{
   case TypeCode:Int32:
   case TypeCode.Int64:
     //dosomething here
     break;
   default: return;
}

Це насправді не відповідає вашому запитанню, але враховуючи, що між компільованими версіями буде незначна різниця, я б закликав вас написати свій код таким чином, який найкраще описує ваші наміри. Не тільки є більший шанс компілятора зробити те, що ви очікуєте, але це полегшить збереження вашого коду для інших.

Якщо ваш намір полягає в розгалуженні вашої програми на основі значення однієї змінної / атрибута, тоді оператор перемикання найкраще представляє цей намір.

Якщо ваш намір полягає у розгалуженні вашої програми на основі різних змінних / атрибутів / умов, тоді це завдання if / else, якщо ланцюжок найкраще представляє цей намір.

Я підтверджую, що коді є правильним щодо того, що люди забувають команду break, але майже так само часто я бачу людей, які роблять складні випадки, коли блоки, де вони помиляються {}, значить, рядки, які мають бути в умовному заяві, не є. Це одна з причин, коли я завжди включаю {} у свої заяви if, навіть якщо в ньому є один рядок. Це не тільки легше читати, але якщо мені потрібно додати ще один рядок у умовному, я не можу забути додати його.

Питання інтересу. Це з’явилося кілька тижнів тому на роботі, і ми знайшли відповідь, написавши фрагмент прикладу та переглянувши його у .NET Reflector (рефлектор - це приголомшливо! Мені це подобається).

Це те, що ми виявили: Дійсний оператор переключення для будь-якого іншого, крім рядка, збирається в IL як оператор перемикання. Однак якщо це рядок, вона переписується як if / else if / else в IL. Тож у нашому випадку ми хотіли знати, як оператори перемикання порівнюють рядки, наприклад, залежно від регістру тощо, і рефлектор швидко дав нам відповідь. Це було корисно знати.

Якщо ви хочете зробити порівняння з великим регістром на рядках, тоді ви можете використовувати оператор перемикання, оскільки це швидше, ніж виконувати String.Compare в if / else. (Редагувати: Прочитайте, що швидше, увімкніть рядок або накресліть на тип? Для деяких фактичних тестів на ефективність) Однак якщо ви хочете зробити нечутливі до регістру, тоді краще використовувати if / else, оскільки отриманий код не дуже гарний.

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

Найкраще правило - використовувати заяви переключення, якщо це має сенс (серйозно), наприклад:

• це покращує читабельність вашого коду
• ви порівнюєте діапазон значень (float, int) або enum

Якщо вам потрібно маніпулювати значенням, яке подається в оператор переключення (створити тимчасову змінну, на яку слід переключитися), вам, ймовірно, слід використовувати оператор управління if / else.

Оновлення:

Насправді краще перетворити рядок у великі регістри (наприклад, ToUpper()тому що, мабуть, є додаткові оптимізації, які може зробити компілятор щойно вчасно, порівняно з ToLower(). Це мікрооптимізація, проте в тісному циклі це може бути корисним.

Маленька бічна примітка:

Для покращення читабельності операторів переключення спробуйте наступне:

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

Оператор перемикання, безумовно, швидше, ніж якщо, якщо ще. Є найшвидші, які були на ньому поставлені BlackWasp

http://www.blackwasp.co.uk/SpeedTestIfElseSwitch.aspx

--Перевір

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

Думаю, не лише на C #, а й на всіх мовах на основі С: оскільки перемикач обмежений константами, можливо створити дуже ефективний код за допомогою "таблиці перестрибування". Випадок C - це справді хороший старий FORTRAN, який обчислюється 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 та переключати заяви! Дуже корисно, коли потрібно перевірити передумови.

if (string.IsNullOrEmpty(line))
{
    //skip empty lines
}
else switch (line.Substring(0,1))
{
    case "1":
        Console.WriteLine(line);
        break;
    case "9":
        Console.WriteLine(line);
        break;
    default:
        break;
}

Я думаю, що перемикання швидше, ніж якщо умови, наприклад, дивіться, чи є така програма, як:

Напишіть програму, щоб ввести будь-яке число (від 1 до 99) і перевірте, в якому слоті а) 1 - 9, потім слот один б) 11 - 19, потім слот два в) 21-29, потім слот три і так далі до 89- 99

Тоді увімкніть, якщо вам доведеться створити багато умов, але випадок перемикання сина ви повинні просто набрати

Вимикач (немає / 10)

а у випадку 0 = 1-9, випадок 1 = 11-19 тощо

це буде так просто

Є ще багато таких прикладів!

заява перемикання в основному є порівнянням для рівності. У події клавіатури є велика перевага перед оператором переключення, коли легко писати та читати код, тоді, якщо заява ififf не буде, відсутність {кронштейна} також може викликати занепокоєння.

char abc;
switch(abc)
{
case a: break;
case b: break;
case c: break;
case d: break;
}

Заява if elseif чудово підходить для більш ніж одного рішення, якщо (theAmountOfApples більше, ніж 5 && theAmountOfApples менше 10), збережіть ваші яблука ще, якщо (theAmountOfApples більше 10 || theAmountOfApples == 100) продаєте ваші яблука. Я не пишу c # або c ++, але я навчився цього, перш ніж я дізнався Java, і вони є близькими мовами.

Один з можливих недоліків операторів переключення - це відсутність кількох умов. Ви можете мати кілька умов для операторів if (else), але не декілька випадків з різними умовами в комутаторі.

Оператори перемикання не підходять для логічних операцій, що виходять за межі простих булевих рівнянь / виразів. Для цих булевих рівнянь / виразів це виразно підходить, але не для інших логічних операцій.

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

Обидва мають місце в залежності від контексту того, з чим стикаєтесь.