Apakah ada perbedaan yang signifikan antara menggunakan if / else dan switch-case di C #?

Apa manfaat / kerugian menggunakan switchpernyataan vs. if/elsedalam C #. Saya tidak bisa membayangkan ada perbedaan besar, selain mungkin tampilan kode Anda.

Apakah ada alasan mengapa IL yang dihasilkan atau kinerja runtime terkait akan sangat berbeda?

Terkait: Apa yang lebih cepat, aktifkan string atau kalau tidak ketik?

Pernyataan SWITCH hanya menghasilkan perakitan yang sama dengan IF dalam mode debug atau kompatibilitas. Dalam rilis, itu akan dikompilasi ke dalam tabel lompatan (melalui pernyataan 'saklar' MSIL) - yaitu O (1).

C # (tidak seperti banyak bahasa lain) juga memungkinkan untuk mengaktifkan konstanta string - dan ini bekerja sedikit berbeda. Jelas tidak praktis untuk membuat tabel lompatan untuk string yang panjangnya sewenang-wenang, jadi paling sering saklar semacam itu akan dikompilasi ke dalam tumpukan IF.

Tetapi jika jumlah kondisi cukup besar untuk menutupi overhead, kompiler C # akan membuat objek HashTable, isi dengan konstanta string dan buat pencarian di atas meja itu diikuti dengan lompatan. Pencarian Hashtable tidak sepenuhnya O (1) dan memiliki biaya konstan yang nyata, tetapi jika jumlah label kasus besar, itu akan secara signifikan lebih cepat daripada membandingkan dengan setiap string konstan dalam IF.

Singkatnya, jika jumlah kondisi lebih dari 5 atau lebih, pilih SWITCH daripada IF, jika tidak gunakan apa pun yang terlihat lebih baik.

Secara umum (mempertimbangkan semua bahasa dan semua kompiler) pernyataan switch DAPAT SESUATU lebih efisien daripada pernyataan if / else, karena mudah bagi kompiler untuk menghasilkan tabel lompatan dari pernyataan switch. Dimungkinkan untuk melakukan hal yang sama untuk pernyataan if / else, dengan batasan yang sesuai, tetapi itu jauh lebih sulit.

Dalam kasus C #, ini juga benar, tetapi karena alasan lain.

Dengan sejumlah besar string, ada keuntungan kinerja yang signifikan untuk menggunakan pernyataan switch, karena kompiler akan menggunakan tabel hash untuk mengimplementasikan lompatan.

Dengan sejumlah kecil string, kinerja keduanya sama.

Ini karena dalam kasus itu kompiler C # tidak menghasilkan tabel lompatan. Alih-alih itu menghasilkan MSIL yang setara dengan blok IF / ELSE.

Ada instruksi MSIL "switch statement" yang ketika dipasangkan akan menggunakan tabel lompat untuk mengimplementasikan pernyataan switch. Namun, ini hanya bekerja dengan tipe integer (pertanyaan ini menanyakan tentang string).

Untuk sejumlah kecil string, ini lebih efisien bagi kompiler untuk menghasilkan blok IF / ELSE daripada menggunakan tabel hash.

Ketika saya awalnya memperhatikan hal ini, saya membuat asumsi bahwa karena blok IF / ELSE digunakan dengan sejumlah kecil string, maka kompiler melakukan transformasi yang sama untuk sejumlah besar string.

Ini SALAH. 'IMA' cukup baik untuk menunjukkan hal ini kepada saya (well ... dia tidak baik tentang itu, tapi dia benar, dan saya salah, yang merupakan bagian penting)

Saya juga membuat asumsi berkepala tentang kurangnya "saklar" instruksi di MSIL (saya pikir, jika ada saklar primitif, mengapa mereka tidak menggunakannya dengan tabel hash, jadi tidak boleh ada saklar primitif. ...). Ini salah, dan sangat bodoh di pihak saya. Sekali lagi 'IMA' menunjukkan ini kepada saya.

Saya membuat pembaruan di sini karena itu adalah posting berperingkat tertinggi, dan jawaban yang diterima.

Namun, saya telah membuatnya menjadi Komunitas Wiki karena saya pikir saya tidak pantas menerima REP karena salah. Jika Anda mendapat kesempatan, silakan pilih posting 'ima'.

Tiga alasan untuk memilih switch:

• Sebuah kompiler yang menargetkan kode asli sering dapat mengkompilasi pernyataan switch ke satu cabang kondisional ditambah lompatan tidak langsung sedangkan urutan ifs membutuhkan urutan cabang kondisional . Tergantung pada kepadatan kasus, banyak makalah yang dipelajari telah ditulis tentang bagaimana menyusun laporan kasus secara efisien; beberapa ditautkan dari halaman kompiler lcc . (Lcc memiliki salah satu kompiler yang lebih inovatif untuk sakelar.)

• Pernyataan switch adalah pilihan di antara alternatif yang saling eksklusif dan sintaksis saklar membuat aliran kontrol ini lebih transparan kepada programmer daripada sarang pernyataan if-then-else.

• Dalam beberapa bahasa, termasuk pasti ML dan Haskell, kompiler akan memeriksa untuk melihat apakah Anda telah meninggalkan kasus apa pun . Saya melihat fitur ini sebagai salah satu keunggulan utama ML dan Haskell. Saya tidak tahu apakah C # dapat melakukan ini.

Sebuah anekdot: pada sebuah kuliah yang dia berikan ketika menerima penghargaan untuk pencapaian seumur hidup, saya mendengar Tony Hoare mengatakan bahwa dari semua hal yang dia lakukan dalam karirnya, ada tiga yang paling dia banggakan:

• Menemukan Quicksort
• Menciptakan pernyataan switch (yang disebut Tony sebagai casestatement)
• Memulai dan mengakhiri karirnya di industri

Saya tidak bisa membayangkan hidup tanpaswitch .

Kompiler akan mengoptimalkan hampir semuanya menjadi kode yang sama dengan perbedaan kecil (Knuth, ada orang?).

Perbedaannya adalah bahwa pernyataan switch lebih bersih dari lima belas jika pernyataan lain dirangkai.

Teman tidak membiarkan teman menumpuk pernyataan if-else.

Sebenarnya, pernyataan switch lebih efisien. Kompiler akan mengoptimalkannya ke tabel mencari di mana dengan pernyataan if / else tidak bisa. Sisi bawahnya adalah bahwa pernyataan switch tidak dapat digunakan dengan nilai variabel.
Anda tidak dapat melakukan:

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

itu harus

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

Saya tidak melihat orang lain meningkatkan (jelas?) Titik bahwa keuntungan efisiensi seharusnya dari pernyataan switch tergantung pada berbagai kasus yang kira-kira sama-sama mungkin. Dalam kasus-kasus di mana satu (atau beberapa) dari nilai-nilai itu jauh lebih mungkin, tangga jika-maka-yang lain bisa lebih cepat, dengan memastikan kasus-kasus yang paling umum diperiksa terlebih dahulu:

Jadi, misalnya:

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

vs.

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

Jika x adalah nol 90% dari waktu, kode "jika lain" bisa dua kali lebih cepat dari kode berbasis switch. Bahkan jika kompiler mengubah "switch" menjadi semacam goto pintar yang digerakkan oleh tabel, itu masih tidak akan secepat hanya dengan memeriksa nol.

seringkali akan terlihat lebih baik - yaitu akan lebih mudah untuk memahami apa yang terjadi. Mengingat manfaat kinerja akan sangat minimal, pandangan kode adalah perbedaan yang paling penting.

Jadi, jika if / else terlihat lebih baik, gunakan itu, kalau tidak gunakan pernyataan switch.

Topik sampingan, tetapi saya sering khawatir tentang (dan lebih sering melihat) if/ elsedan switchpernyataan terlalu besar dengan terlalu banyak kasus. Ini sering melukai rawatan.

Penyebab umum meliputi:

1. Melakukan terlalu banyak di dalam banyak jika pernyataan
2. Lebih banyak pernyataan kasus daripada yang mungkin dianalisis secara manusiawi
3. Terlalu banyak syarat dalam evaluasi if untuk mengetahui apa yang dicari

Memperbaiki:

1. Ekstrak ke Metode refactoring.
2. Gunakan Kamus dengan pointer metode alih-alih sebuah case, atau gunakan IoC untuk menambah konfigurasi. Metode pabrik juga dapat membantu.
3. Ekstrak kondisi ke metode mereka sendiri

Sesuai tautan ini, perbandingan IF vs Switch dari tes iterasi menggunakan switch dan if statement, seperti untuk 1.000.000.000 iterasi, Waktu yang diambil oleh Switch Statement = 43.0s & oleh If Statement = 48.0s

Yang secara harfiah adalah 20833333 iterasi per detik, Jadi, Jika kita benar-benar perlu lebih fokus,

PS: Hanya untuk mengetahui perbedaan kinerja untuk daftar kecil kondisi.

Jika Anda hanya menggunakan pernyataan if atau lainnya, solusi dasar menggunakan perbandingan? operator

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

Anda dapat melakukan atau rutin dalam suatu saklar

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

Ini sebenarnya tidak menjawab pertanyaan Anda, tetapi mengingat akan ada sedikit perbedaan antara versi yang dikompilasi, saya akan mendorong Anda untuk menulis kode Anda dengan cara yang paling menggambarkan niat Anda. Tidak hanya ada peluang yang lebih baik dari kompiler melakukan apa yang Anda harapkan, tetapi juga akan memudahkan orang lain untuk menjaga kode Anda.

Jika niat Anda adalah untuk bercabang program Anda berdasarkan nilai satu variabel / atribut, maka pernyataan switch paling mewakili niat itu.

Jika niat Anda adalah bercabang program Anda berdasarkan variabel / atribut / kondisi yang berbeda, maka rantai if / else jika rantai terbaik mewakili niat itu.

Saya akan mengabulkan bahwa cody benar tentang orang yang melupakan perintah break, tetapi hampir sering saya melihat orang melakukan rumit jika blok di mana mereka mendapatkan {} salah, sehingga baris yang seharusnya dalam pernyataan kondisional tidak. Itu salah satu alasan saya selalu memasukkan {} pada pernyataan if saya meskipun ada satu baris di dalamnya. Tidak hanya lebih mudah dibaca, tetapi jika saya perlu menambahkan baris lain dalam kondisional, saya tidak bisa lupa untuk menambahkannya.

Pertanyaan minat. Ini muncul beberapa minggu yang lalu di tempat kerja dan kami menemukan jawaban dengan menulis cuplikan contoh dan melihatnya di. NET Reflector (reflektornya luar biasa !! Saya menyukainya).

Inilah yang kami temukan: Pernyataan switch yang valid untuk apa pun selain string akan dikompilasi ke IL sebagai pernyataan switch. Namun JIKA itu adalah string itu ditulis ulang sebagai if / else if / else di IL. Jadi dalam kasus kami, kami ingin tahu bagaimana pernyataan peralihan membandingkan string, misalnya, peka terhadap huruf, dll. Dan reflektor dengan cepat memberi kami jawaban. Ini berguna untuk diketahui.

Jika Anda ingin melakukan perbandingan case-sensitif pada string maka Anda bisa menggunakan pernyataan switch karena lebih cepat daripada melakukan String. Bandingkan dalam if / else. (Sunting: Baca Apa yang lebih cepat, aktifkan string atau jika tidak ketik? Untuk beberapa tes kinerja aktual) Namun jika Anda ingin melakukan case-insensitive maka lebih baik menggunakan if / else karena kode yang dihasilkan tidak cantik.

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

Aturan praktis terbaik adalah dengan menggunakan pernyataan switch jika masuk akal (serius), misalnya:

• itu meningkatkan keterbacaan kode Anda
• Anda membandingkan rentang nilai (float, int) atau enum

Jika Anda perlu memanipulasi nilai untuk dimasukkan ke dalam pernyataan switch (buat variabel sementara untuk beralih melawan) maka Anda mungkin harus menggunakan pernyataan kontrol if / else.

Sebuah pembaharuan:

Sebenarnya lebih baik untuk mengonversi string menjadi huruf besar (misalnya ToUpper()) karena yang telah ada ternyata ada optimasi lebih lanjut bahwa kompiler just-in-time dapat melakukan seperti ketika dibandingkan dengan ToLower(). Ini adalah optimasi mikro, namun dalam lingkaran yang ketat itu bisa berguna.

Catatan kecil:

Untuk meningkatkan keterbacaan pernyataan beralih coba yang berikut ini:

• letakkan cabang yang paling mungkin pertama yaitu paling banyak diakses
• jika semuanya mungkin terjadi, buatlah daftar dalam urutan abjad sehingga lebih mudah untuk menemukannya.
• jangan pernah menggunakan tangkapan standar-semua untuk kondisi terakhir yang tersisa, itu malas dan akan menyebabkan masalah nanti dalam kehidupan kode.
• gunakan catch-all default untuk menyatakan kondisi yang tidak diketahui meskipun sangat tidak mungkin terjadi. itulah gunanya menegaskan.

Pernyataan peralihan jelas lebih cepat dari pada if if if if. Ada speedtest yang disediakan oleh BlackWasp

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

--Saksikan berikut ini

Tetapi sangat bergantung pada kemungkinan yang Anda coba pertanggungjawabkan, tetapi saya mencoba menggunakan pernyataan peralihan bila memungkinkan.

Bukan hanya C #, tetapi semua bahasa berbasis C, saya pikir: karena sebuah saklar terbatas pada konstanta, dimungkinkan untuk menghasilkan kode yang sangat efisien menggunakan "tabel lompatan". Kasing C benar-benar FORTRAN tua yang baik dihitung GOTO, tetapi kasing C # masih menguji terhadap konstan.

Ini bukan masalah bahwa pengoptimal akan dapat membuat kode yang sama. Pertimbangkan, misalnya,

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

Karena itu adalah boolean majemuk, kode yang dihasilkan harus menghitung nilai, dan sirkuit pendek. Sekarang pertimbangkan yang setara

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

Ini dapat dikompilasi menjadi

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

karena Anda secara implisit memberi tahu kompiler bahwa ia tidak perlu menghitung tes OR dan kesetaraan.

Profesor cs saya menyarankan agar Anda tidak beralih pernyataan karena begitu sering orang lupa istirahat atau menggunakannya dengan salah. Saya tidak dapat mengingat dengan tepat apa yang dia katakan tetapi sesuatu di sepanjang baris yang melihat beberapa basis kode mani yang menunjukkan contoh pernyataan switch (tahun lalu) juga memiliki banyak kesalahan di dalamnya.

Sesuatu yang saya perhatikan adalah Anda dapat menggabungkan if / else dan beralih pernyataan! Sangat berguna ketika perlu memeriksa prasyarat.

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

I Think Switch Lebih Cepat Daripada Jika Syaratnya Suka Melihat Ada Program Seperti:

Tulis Program untuk memasukkan angka (antara 1 - 99) dan periksa di slot mana a) 1 - 9 lalu slot satu b) 11 - 19 lalu slot dua c) 21-29 lalu slot tiga dan seterusnya hingga 89- 99

Kemudian Aktif Jika Anda Harus Membuat Banyak Kondisi Tetapi Son Switch Case, Anda Harus Mengetik Saja

Switch (no / 10)

dan pada case 0 = 1-9, case 1 = 11-19 dan seterusnya

itu akan sangat mudah

Ada Banyak Lagi Contoh Seperti Itu Juga!

pernyataan switch pada dasarnya adalah perbandingan untuk kesetaraan. acara keyboard memiliki keuntungan besar daripada beralih pernyataan ketika memiliki mudah untuk menulis dan membaca kode maka pernyataan if ifif akan, kehilangan {bracket} bisa mendapatkan masalah juga.

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

Pernyataan ifif jika bagus untuk lebih dari satu solusi jika (jumlahOfApples lebih besar dari 5&&mountOfApples kurang dari 10) simpan apel Anda lagi jika (jumlahOfApples lebih besar dari 10 || theAmountOfApples menjual apel Anda. Saya tidak menulis c # atau c ++ tapi saya mempelajarinya sebelum saya belajar java dan mereka adalah bahasa yang dekat.

Salah satu kemungkinan kerugian dari pernyataan switch adalah kurangnya beberapa kondisi. Anda dapat memiliki beberapa kondisi untuk if (else) tetapi tidak banyak statement cases dengan kondisi berbeda dalam switch.

Pernyataan switch tidak cocok untuk operasi logika di luar lingkup persamaan / ekspresi Boolean sederhana. Untuk persamaan / ekspresi Boolean itu, sangat cocok tetapi tidak untuk operasi logika lainnya.

Anda memiliki lebih banyak kebebasan dengan logika yang tersedia di pernyataan If tetapi keterbacaan dapat menderita jika pernyataan If menjadi berat atau ditangani dengan buruk.

Keduanya ada di sana tergantung pada konteks apa yang Anda hadapi.