C# melaksanakan mekanisme pengendalian pengecualian berstruktur melalui percubaan, menangkap dan akhirnya blok. Pemaju meletakkan kod ralat yang mungkin di blok cuba, menangkap pengecualian tertentu (seperti IOException, SQLException) di blok tangkapan, dan melakukan pembersihan sumber di blok akhirnya. 1. Pengecualian khusus harus ditangkap dan bukannya pengecualian umum (seperti pengecualian) untuk mengelakkan menyembunyikan kesilapan yang serius dan meningkatkan kecekapan debug; 2. Elakkan penggunaan terlalu banyak digunakan dalam kod prestasi kritikal. Adalah disyorkan untuk memeriksa keadaan terlebih dahulu atau menggunakan kaedah seperti TryParse; 3. Sentiasa melepaskan sumber dalam blok akhirnya atau menggunakan pernyataan untuk memastikan bahawa fail, sambungan, dan lain -lain ditutup dengan betul; 4. Apabila membangunkan perpustakaan, anda harus mengendalikan pengecualian dengan teliti, cuba biarkan pengecualian dibuang, dan jika anda perlu menangkapnya, gunakan lemparan; Kekalkan maklumat stack atau merangkumi untuk menambah konteks kepada pengecualian baru, dengan itu meningkatkan keupayaan diagnosis ralat.

C# mengendalikan pengecualian menggunakan mekanisme pengendalian pengecualian berstruktur berdasarkan try , catch , dan finally blok. Sistem ini membolehkan pemaju untuk menguruskan ralat runtime dengan anggun tanpa merosakkan permohonan. Idea asas ialah anda meletakkan kod yang berpotensi bermasalah di dalam blok try , mengendalikan sebarang pengecualian dalam satu atau lebih blok catch , dan gunakan blok finally untuk kod pembersihan yang selalu berjalan -sama ada pengecualian berlaku atau tidak.

Gunakan pengecualian tertentu dalam blok tangkapan

Salah satu amalan terbaik yang paling penting ketika bekerja dengan blok catch adalah untuk menangkap pengecualian tertentu dan bukannya umum. Sebagai contoh, penangkapan Exception mungkin kelihatan mudah, tetapi ia boleh menyembunyikan pepijat atau isu -isu yang tidak dijangka seperti OutOfMemoryException atau StackOverflowException , yang lebih baik dibiarkan tidak dilancarkan kecuali anda mempunyai alasan yang sangat baik untuk berbuat demikian.

Sebaliknya:

• Tangkap pengecualian yang diketahui seperti IOException , SqlException , atau NullReferenceException
• Mengendalikan setiap jenis secara berasingan jika diperlukan
• Elakkan menulis blok tangkapan kosong (seperti catch {} ) -mereka dengan senyap menelan kesilapan

Pendekatan ini menjadikan debugging lebih mudah dan mengekalkan logik pengendalian kesilapan anda yang difokuskan dan bermakna.

Jangan terlalu banyak mencuba dalam kod prestasi prestasi

Walaupun pengendalian pengecualian berkuasa, ia juga agak mahal dari segi prestasi -terutamanya apabila pengecualian sebenarnya dilemparkan. Membuang pengecualian melibatkan menangkap maklumat stack, yang memerlukan masa.

Jadi:

• Elakkan meletakkan blok coba di dalam gelung yang ketat kecuali perlu
• Sekiranya boleh, periksa syarat sebelum melakukan operasi yang boleh dibuang (misalnya, periksa sama ada fail wujud sebelum cuba membukanya)
• Pengendalian Pengecualian Rizab untuk keadaan yang benar -benar luar biasa, bukan untuk aliran kawalan biasa

Sebagai contoh, bukannya menangkap FormatException apabila parsing input pengguna, pertimbangkan untuk menggunakan kaedah TryParse() yang mengembalikan boolean dan bukannya membuang pengecualian.

Sentiasa gunakan akhirnya untuk pembersihan sumber

finally blok adalah di mana anda perlu meletakkan kod pembersihan seperti fail penutup, sambungan pangkalan data, atau soket rangkaian. Walaupun pengecualian dibuang dan ditangkap, blok finally masih akan dilaksanakan, memastikan sumber dilepaskan dengan betul.

Corak biasa kelihatan seperti ini:

 FileStream FS = null;
Cuba
{
    fs = filestream baru ("file.txt", fileMode.Open);
    // Lakukan sesuatu dengan fail
}
Tangkap (ioException Ex)
{
    // Handle IOException
}
Akhirnya
{
    jika (fs! = null)
        fs.dispose ();
}

Sebagai alternatif, lebih suka menggunakan pernyataan using jenis yang melaksanakan IDisposable . Ia secara automatik membungkus objek dalam blok percubaan-finally dan panggilan Dispose() untuk anda:

 Menggunakan (var fs = FileStream baru ("file.txt", fileMode.Open))
{
    // Lakukan sesuatu dengan fail
}

Ia lebih bersih dan kurang rawan kesilapan.

Pertimbangkan penyebaran pengecualian semasa merancang perpustakaan

Apabila menulis perpustakaan atau komponen yang boleh diguna semula, berhati -hati tentang bagaimana pengecualian dikendalikan. Dalam banyak kes, lebih baik untuk membiarkan pengecualian menyebarkan timbunan panggilan daripada menangkap dan melengkapkan mereka terlalu awal. Dengan cara itu, kod peringkat tinggi mempunyai peluang untuk memutuskan bagaimana untuk bertindak balas terhadap kesilapan.

Sekiranya anda perlu menangkap pengecualian:

• Membuangnya menggunakan throw; Daripada throw ex; untuk mengekalkan jejak timbunan asal
• Balut dalam pengecualian yang lain hanya apabila menambah konteks yang berguna

Contoh:

 Tangkap (ioException Ex)
{
    membuang CustomDataAccessException baru ("gagal membaca data.", Ex);
}

Ini mengekalkan kejelasan debugging sambil memberikan maklumat ralat yang lebih kaya.

Pada dasarnya itu sahaja. Pengendalian pengecualian di C# cukup mudah apabila anda memahami cara menyusun blok anda dan apa jenis pengecualian yang diharapkan. Teruskan menangkap khusus, membersihkan akhirnya (atau gunakan using ), dan berfikir dengan teliti sama ada untuk mengendalikan atau menyebarkan pengecualian bergantung kepada peranan anda dalam timbunan aplikasi.

Atas ialah kandungan terperinci Bagaimanakah C# mengendalikan pengecualian, dan apakah amalan terbaik untuk blok percubaan-catch-finally?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!