Berurusan dengan sup penahan keriting

Saya telah memprogram dalam C # dan VB.NET selama bertahun-tahun, tetapi terutama dalam VB. Saya membuat perubahan karier menuju C # dan, secara keseluruhan, saya suka C # lebih baik.

Satu masalah yang saya alami adalah sup keriting. Di VB, setiap kata kunci struktur memiliki kata kunci tutup yang cocok, misalnya:

Namespace ...
    Class ...
        Function ...
            For ...
                Using ...
                    If ...
                        ...
                    End If
                    If ...
                        ...
                    End If
                End Using
            Next
        End Function
    End Class
End Namespace

Kode yang sama yang ditulis dalam C # sangat sulit dibaca:

namespace ... {
    class ... {
        function ... {
            for ... {
                using ... {
                    if ... {
                        ...
                    }
                    if ... {
                        ...
                    }
                }
            }
            // wait... what level is this?
        }
    }
}

Karena sudah terbiasa dengan VB, saya bertanya-tanya apakah ada teknik yang digunakan oleh programmer c-style untuk meningkatkan keterbacaan dan untuk memastikan bahwa kode Anda berakhir di "blok" yang benar. Contoh di atas relatif mudah dibaca, tetapi kadang-kadang di akhir sepotong kode saya akan memiliki 8 atau lebih tingkat kurung kurawal, mengharuskan saya untuk menggulir ke atas beberapa halaman untuk mengetahui penjepit mana yang mengakhiri blok saya tertarik di.

Letakkan brace keriting awal Anda di "peringkat" yang sama dengan yang akhir Anda, seperti ini:

namespace ... 
{
    class ... 
    {
        function ... 
        {
            for ... 
            {
                using ... 
                {
                    if ... 
                    {
                        ...
                    }
                    if ... 
                    {
                        ...
                    }
                }
            }
            // It's the `function` level!
        }
    }
}

• Bergantung pada IDE Anda: letakkan kursor Anda pada kurung buka / tutup dan itu akan menyoroti itu dan kurung yang sesuai.
• Perkecil blok dan ini menunjukkan di mana ia membuka / menutup.
• Tulis blok kode yang lebih kecil. Serius. Lihat Clean Code, dan jangan pernah mengalami masalah ini lagi (dan memiliki lebih banyak kode yang dapat dibaca / dikelola).

Satu catatan, berikut ini adalah sintaksis c # yang valid yang mungkin membantu situasi khusus Anda:

using (var type = new MyDisposable1())
using (var type2 = new MyDisposable2())
{
    /* do what you will with type2 and type2 */
}

Konvensi umum adalah menambahkan komentar setelah kurung kurawal untuk menunjukkan struktur yang ditutup:

if {
   ...
} // end if

while (condition) {
   ...
} // end while

dll. Saya sendiri tidak pernah melakukan pemanasan pada konvensi ini, tetapi beberapa orang merasa terbantu.

Secara umum, ketika menjadi sulit untuk mencocokkan kawat gigi dalam gaya apa pun - itu mungkin berarti metode ini terlalu panjang dan harus difaktorkan ulang.

Saya pikir Anda perlu tangguh dengan kawat gigi. Akhirnya mereka akan menjadi kebiasaan bagi Anda dan Anda akan bertanya-tanya bagaimana Anda bisa hidup tanpanya.

Pastikan mereka diberi indentasi dengan benar, dan bahwa beberapa konvensi spasi sedang diikuti (tidak masalah yang mana).

Saya menghapus 2 level bersarang dengan menciutkan namespace dan cakupan kelas secara horizontal. Perhatikan metode yang rata dengan tepi kiri layar. Saya tidak melihat gunanya kehilangan 2 level indentasi di setiap file.

Setelah itu jarang Anda akan memiliki kedalaman lebih dari 4 level.

namespace FooNameSpace {
class Foo {

public void bar()
{
    while(true)
    {
        while(true)
        {
            break;
        }
    }
}

public void fooBar()
{
    foreach(var item in FooList)
    {
        foreach(var b in item.Bars)
        {
            if(b.IsReady)
            {
                bar();
            }
            bar();
        }
        bar();
    }
}

}}//end class, namespace

Saya baru-baru ini memutuskan untuk mencoba dan meresmikan dua aturan tentang konstruksi kontrol aliran yang pada dasarnya seperti ini:

• Anda seharusnya tidak memiliki apa pun kecuali konstruksi aliran kode yang diperlukan
• Anda harus membuat konstruksi aliran kode sekecil mungkin

Untuk alasan persisnya yang telah Anda sebutkan dan sadari, saya pikir ini adalah aturan yang bagus untuk diikuti. Ada beberapa teknik sederhana yang dapat Anda terapkan untuk mencapainya:

• Keluar dari ruang lingkup sesegera mungkin (ini termasuk ruang lingkup loop serta fungsi)
• Perhatikan elses yang dapat dikurangi dengan keluar dari fungsi sebelumnya jika dan menerapkan teknik keluar lingkup seperti yang saya sebutkan
• Membalikkan pemeriksaan bersyarat Anda ketika kode di dalam if lebih besar dari itu di luar
• Kode faktor di dalam loop ke metode lain ketika ukuran loop tumbuh untuk mengaburkan sisa metode
• Perhatikan setiap lingkup yang hanya berisi ruang lingkup lain, misalnya fungsi yang seluruh ruang lingkupnya diisi oleh if dengan tidak ada yang di luar if

Saya merinci di sini contoh bagaimana tidak mengikuti ini dapat berakhir dengan Anda melakukan seperti yang Anda katakan dan meletakkan kode di blok kode yang salah, yang buruk dan penyebab mudah bug muncul selama pemeliharaan.

Sayangnya, ini adalah salah satu penyebab peperangan tertua dalam komputasi. Argumen yang masuk akal dapat dibuat dari kedua belah pihak (ekonomi real-estate vertikal yang lebih baik versus kemampuan yang lebih mudah untuk mencocokkan brace pembuka secara visual dengan brace penutup), tetapi dalam kenyataannya format-kode sumber sederhana akan menyelesaikan segalanya untuk Anda. MS Visual C # memiliki satu built in yang berfungsi dengan baik.

Namun berhati-hatilah bahwa jika Anda bekerja sebagai bagian dari tim, Anda akan diharapkan untuk menyesuaikan diri dengan konvensi yang digunakan oleh tim itu, sehingga membayar untuk mendapatkan keakraban dengan kedua gaya dan menahan diri dari menjadi religius atas gaya penyangga.

Jadi sementara Anda belajar, tentu saja, fokuslah pada gaya yang membuatnya lebih mudah bagi Anda untuk belajar, tetapi tetap awasi yang lain saat Anda melakukannya dan Anda akan baik-baik saja.

Gunakan Resharper, yang akan membantu merekomendasikan cara untuk mengurangi sarang. Juga, baca buku Clean Code dari Bob Martin , yang menekankan bahwa suatu fungsi seharusnya hanya melakukan satu hal, dan oleh karena itu setiap fungsi hanya memiliki panjang setengah lusin baris, sehingga Anda tidak perlu khawatir tentang banyak tingkat sarang.

Ada add-on untuk editor yang dapat membantu Anda di: C # Outline .

Add-on memperluas editor VS20xx untuk C # dengan menambahkan fitur untuk menutup, memperluas dan menyoroti blok kode bersarang. Fitur-fitur ini memungkinkan pengeditan dan pembacaan konten blok kode yang bersarang seperti jika, sementara, dll.

Jika Anda menulis Kode di Visual Studio, ada juga Plugin yang menunjukkan Anda titik-titik vertikal antara awal dan akhir setiap struktur yang Anda buat.

Tapi secara keseluruhan saya pikir itu hanya akan memakan waktu sampai Anda terbiasa dengan "Curly-Braces-Soup". (Btw, aku sangat suka ungkapan itu. Kedengarannya agak seperti Episode-Name untuk The Big Bang Theory)

Lekukan memberi tahu Anda di mana Anda berada, dalam kedua gaya sintaksis. Jika Anda menulis program VB atau program C # pada satu baris, Anda akan segera tidak dapat mengetahui di mana di sintaks bersarang Anda. Mesin mem-parsing frasa akhir blok atau kurung kurawal, tetapi manusia membutuhkan lekukan.

Frasa pemblokiran akhir berasal dari era kartu berlubang dan pita kertas, ketika pemrograman kurang interaktif dan visual. Atau, sungguh, tidak interaktif sama sekali. Itu sulit untuk memasukkan program, dan programmer membutuhkan kompiler untuk menjadi sangat pintar tentang analisis sintaksis dan pemulihan kesalahan.

Di masa lalu, siklus sunting-kompilasi-lari mungkin melibatkan mempersiapkan kartu berlubang dengan pemukul kartu, dan kemudian berbaris ke jendela pengajuan pekerjaan di mana petugas mengambil kartu-kartu yang dilubangi dan menyerahkannya ke mesin. Kemudian, programmer akan mengumpulkan output (dicetak di atas kertas) dari jendela lain. Jika program memiliki kesalahan, output hanya akan terdiri dari diagnostik kompiler. Ketika waktu penyelesaian yang lama, biaya tambahan mengetik end ifbukan hanya )dibenarkan jika membantu meningkatkan kualitas diagnostik, karena programmer harus memperbaiki kesalahan sebanyak mungkin dalam satu iterasi tunggal untuk mengurangi jumlah waktu yang terbuang. iterasi melalui jendela pengiriman pekerjaan.

Ketika kurung kurawal penutupan hilang, sulit untuk mengatakan mana kurung kurawal terbuka yang tidak ditutup. (Kompilator mungkin harus mengurai indentasi untuk membuat tebakan yang terpelajar.) Jika Anda menghapus kurung kurawal di dalam suatu fungsi, maka sepertinya seluruh sisa file adalah bagian dari fungsi itu, yang mengakibatkan kesibukan pesan kesalahan yang tidak membantu. Sedangkan jika Anda memiliki end functionsintaks, kompiler dapat menyimpulkan di mana fungsi yang salah berakhir, memulihkan, dan menguraikan fungsi berikutnya dengan benar, memberi Anda diagnostik tambahan, jika ada, yang bermakna.

Ketika Anda bekerja di editor teks yang sadar kode yang secara otomatis mengindentasi dan mewarnai kode Anda, pada layar resolusi tinggi di mana Anda dapat melihat enam puluh atau lebih baris, argumen untuk jenis bahasa canggung itu tidak lagi berlaku. Anda dapat mengedit dan membangun kembali program secara bertahap secara bertahap sehingga Anda dapat menangani satu kesalahan sekaligus. Selain itu, dengan melihat bagian besar dari program secara bersamaan di layar dan mempertahankan lekukan yang tepat, Anda dapat mengurangi terjadinya jenis kesalahan bersarang di tempat pertama. Dan editor teks pemrograman yang baik bahkan akan menandai beberapa jenis kesalahan sintaks saat Anda mengetik. Terlebih lagi, ada editor lipat yang akan menciutkan blok program berdasarkan sintaksnya, memberikan tampilan "seperti garis besar" dari strukturnya.

Lisp menggunakan tanda kurung dari awal dan mungkin, bukan kebetulan, peretas Lisp memelopori pemrograman sebagai pengalaman interaktif dengan membangun sistem yang menerima program dalam potongan kecil (ekspresi).

Bahkan, Anda tidak perlu mengakhiri simbol sama sekali, seperti yang diilustrasikan oleh bahasa Python. Identation hanya bisa menjadi struktur. Manusia sudah menggunakan lekukan untuk mendapatkan struktur kode bahkan dalam bahasa di mana mesin bergantung pada simbol atau frasa berakhir.

Jika Anda menggunakan IDE, Cukup tekan Crtl+ k+ Ddan IDE akan melakukan pekerjaan selanjutnya.