Exception Handling C#: Kuasai Try Catch Finally untuk Kode Robust

Foto oleh KATRIN BOLOVTSOVA via Pexels

Menguasai Exception Handling di C#: Peran Penting Try, Catch, dan Finally

Halo teman-teman Malam Ngoding! Pernahkah Anda menyaksikan aplikasi kesayangan Anda tiba-tiba berhenti bekerja dengan pesan error misterius, atau bahkan langsung menutup diri tanpa peringatan? Kejadian seperti itu tentu sangat mengganggu pengalaman pengguna, dan bagi developer, itu adalah pertanda ada sesuatu yang salah dalam cara program menangani kondisi tak terduga.

Di dunia nyata pengembangan perangkat lunak, tidak semua hal berjalan sesuai rencana. Koneksi database bisa putus, file yang dicari tidak ditemukan, input pengguna bisa saja tidak valid, atau layanan eksternal yang kita andalkan sedang mengalami masalah. Semua skenario ini adalah contoh 'pengecualian' atau exception, kondisi abnormal yang dapat mengganggu alur eksekusi normal program kita.

C# menyediakan mekanisme yang kuat dan elegan untuk mengatasi skenario ini: Exception Handling, terutama melalui blok try, catch, dan finally. Memahami dan mengimplementasikan exception handling dengan benar adalah kunci untuk membangun aplikasi yang tidak hanya berfungsi, tetapi juga tangguh dan ramah pengguna.

Mengapa Kita Butuh Exception Handling? Sebuah Kebutuhan Fundamental

Bayangkan Anda sedang mengembangkan aplikasi perbankan. Seorang pengguna mencoba menarik uang, tetapi saldo mereka tidak mencukupi. Apakah aplikasi harus langsung crash dan menampilkan pesan error teknis yang menakutkan? Tentu tidak. Ini adalah salah satu skenario di mana exception handling menjadi krusial.

Sebelum adanya mekanisme exception handling yang modern, developer seringkali harus mengandalkan kode pengecekan error manual seperti mengembalikan nilai boolean, kode error numerik, atau objek khusus. Pendekatan ini seringkali membuat kode menjadi sangat berantakan (spaghetti code) karena logika bisnis utama tercampur aduk dengan puluhan baris kode pengecekan error.

Exception handling mengatasi masalah ini dengan memisahkan logika penanganan error dari logika bisnis utama. Ketika sebuah kondisi abnormal terjadi, program akan 'melemparkan' (throw) sebuah pengecualian. Pengecualian ini kemudian dapat 'ditangkap' (catch) oleh bagian lain dari kode yang bertanggung jawab untuk menanganinya, memungkinkan aplikasi untuk merespons secara terkendali tanpa harus berhenti total. Ini menghasilkan kode yang lebih bersih, mudah dibaca, dan lebih mudah dipelihara.

Memahami Pilar Exception Handling: Try, Catch, dan Finally

Contoh Dasar Try, Catch, dan Finally

using System;
using System.IO;

public class ContohDasar
{
    public static void Main(string[] args)
    {
        try
        {
            // Kode yang berpotensi menyebabkan exception
            Console.WriteLine("Mencoba membaca file...");
            string content = File.ReadAllText("nonExistentFile.txt");
            Console.WriteLine($"Isi file: {content}");
        }
        catch (FileNotFoundException ex)
        {
            // Menangkap exception spesifik: file tidak ditemukan
            Console.WriteLine($"Error: File tidak ditemukan! {ex.Message}");
            // Log detail exception ke sistem logging Anda
        }
        catch (IOException ex)
        {
            // Menangkap exception spesifik lain: masalah I/O
            Console.WriteLine($"Error I/O: Terjadi masalah saat membaca file. {ex.Message}");
        }
        catch (Exception ex)
        {
            // Menangkap exception umum sebagai fallback terakhir
            Console.WriteLine($"Error tak terduga: {ex.Message}");
            // Anda bisa log ex.StackTrace di sini untuk debugging
        }
        finally
        {
            // Kode di sini akan selalu dieksekusi, terlepas dari exception atau tidak
            Console.WriteLine("Operasi pembacaan file selesai (atau gagal). Membersihkan sumber daya jika ada.");
        }

        Console.WriteLine("Program berlanjut setelah exception handling.");
    }
}

Mekanisme utama untuk exception handling di C# adalah blok try-catch-finally. Setiap bagian memiliki peran spesifik:

Blok `try`: Melindungi Kode Anda

Blok try adalah tempat Anda menempatkan kode yang berpotensi menghasilkan pengecualian. Jika sebuah pengecualian terjadi di dalam blok try, eksekusi kode di blok try akan segera dihentikan, dan kendali akan dialihkan ke blok catch yang sesuai. Jika tidak ada pengecualian yang terjadi, blok try akan dieksekusi sampai selesai, dan blok catch akan dilewati.

Blok `catch`: Menangkap dan Mengelola Pengecualian

Setelah sebuah pengecualian dilemparkan di dalam blok try, blok catch akan bertugas untuk 'menangkap' dan menangani pengecualian tersebut. Anda dapat memiliki satu atau lebih blok catch untuk menangani berbagai jenis pengecualian:

Menangkap Exception Spesifik: Ini adalah praktik terbaik. Anda bisa menangkap jenis pengecualian tertentu (misalnya, FormatException untuk kesalahan format input, FileNotFoundException untuk file yang hilang, atau SqlException untuk masalah database). Dengan menangkap pengecualian spesifik, Anda bisa memberikan penanganan yang lebih tepat dan informatif.
Menangkap Exception Umum (Exception): Blok catch (Exception ex) akan menangkap semua jenis pengecualian. Meskipun praktis, penggunaan ini harus hati-hati karena dapat menyembunyikan masalah yang lebih spesifik. Sebaiknya gunakan ini sebagai fallback terakhir setelah menangkap pengecualian yang lebih spesifik.
Multiple catch Blocks: Anda dapat mendefinisikan beberapa blok catch secara berurutan. Penting untuk menempatkan blok catch yang paling spesifik terlebih dahulu, diikuti oleh yang lebih umum. Jika tidak, blok yang lebih umum akan menangkap pengecualian sebelum blok yang lebih spesifik berkesempatan, membuat blok yang lebih spesifik tidak pernah terjangkau.

Di dalam blok catch, Anda memiliki akses ke objek Exception (biasanya disingkat ex). Objek ini berisi informasi penting tentang pengecualian, seperti:

Message: Deskripsi singkat tentang penyebab pengecualian.
StackTrace: Urutan pemanggilan method yang mengarah ke pengecualian, sangat berguna untuk debugging.
InnerException: Jika pengecualian ini disebabkan oleh pengecualian lain, InnerException akan merujuk pada pengecualian awal tersebut.

Blok `finally`: Pastikan Aksi Krusial Terlaksana

Blok finally adalah bagian yang akan selalu dieksekusi, terlepas dari apakah sebuah pengecualian terjadi atau tidak, dan apakah pengecualian tersebut ditangkap atau tidak. Ini adalah tempat yang sempurna untuk menempatkan kode pembersihan sumber daya (resource cleanup).

Contoh umum penggunaan finally adalah untuk:

Menutup koneksi database atau jaringan.
Melepaskan handle file.
Membebaskan memori atau objek yang dipegang secara eksplisit.

Bahkan jika ada return statement di dalam blok try atau catch, blok finally akan tetap dieksekusi sebelum method keluar. Ini memastikan bahwa sumber daya yang diperoleh selalu dilepaskan, mencegah kebocoran sumber daya yang dapat menyebabkan masalah performa atau stabilitas jangka panjang.

Sebagai alternatif untuk banyak skenario resource cleanup, C# juga menyediakan statement using untuk objek yang mengimplementasikan antarmuka IDisposable. Ini adalah cara yang lebih ringkas dan seringkali lebih aman untuk memastikan sumber daya dilepaskan secara otomatis, mirip dengan apa yang bisa dicapai dengan blok finally.

Melempar Pengecualian Sendiri: `throw`

Terkadang, Anda mungkin perlu memberi sinyal bahwa ada masalah dalam method Anda kepada pemanggil. Untuk melakukan ini, Anda bisa 'melemparkan' (throw) pengecualian secara eksplisit menggunakan kata kunci throw. Ini sangat berguna ketika Anda mendeteksi kondisi yang tidak valid di lapisan kode Anda, misalnya, jika sebuah parameter method memiliki nilai di luar rentang yang diizinkan.

Anda juga bisa membuat pengecualian kustom (custom exceptions) dengan mewarisi dari kelas System.Exception. Ini memungkinkan Anda untuk merepresentasikan error spesifik domain aplikasi Anda, membuat kode Anda lebih ekspresif dan mudah dipahami.

Satu hal penting saat melempar kembali pengecualian (re-throwing) adalah perbedaan antara throw; dan throw ex;:

throw; (tanpa variabel): Ini akan melempar kembali pengecualian asli dan mempertahankan stack trace aslinya. Ini adalah praktik yang direkomendasikan jika Anda hanya ingin mencatat pengecualian dan meneruskannya ke pemanggil berikutnya untuk penanganan lebih lanjut.
throw ex; (dengan variabel): Ini akan melempar pengecualian baru dan menghapus informasi stack trace asli dari titik pengecualian terjadi, menggantinya dengan stack trace dari lokasi throw ex;. Ini jarang diinginkan karena mempersulit debugging.

Kapan Menggunakan Exception Handling dan Kapan Tidak? (Trade-offs)

Multiple Catch Blocks dan Properti Exception

using System;

public class ContohMultipleCatch
{
    public static void Main(string[] args)
    {
        Console.Write("Masukkan sebuah angka: ");
        string input = Console.ReadLine();

        try
        {
            int number = int.Parse(input); // Potensi FormatException
            int result = 100 / number;     // Potensi DivideByZeroException
            Console.WriteLine($"Hasil: {result}");
        }
        catch (FormatException ex)
        {
            Console.WriteLine($"Kesalahan input: '{input}' bukan format angka yang valid.");
            Console.WriteLine($"Detail: {ex.Message}");
            // Console.WriteLine($"Stack Trace:\n{ex.StackTrace}"); // Jangan tampilkan di produksi ke user
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine($"Kesalahan matematika: Anda tidak bisa membagi dengan nol!");
            Console.WriteLine($"Detail: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Terjadi kesalahan umum tak terduga: {ex.Message}");
            // Di sini Anda bisa log ex.StackTrace, ex.InnerException jika ada
        }
        finally
        {
            Console.WriteLine("Selesai memproses input.");
        }
    }
}

Meskipun exception handling sangat kuat, menggunakannya secara berlebihan atau pada situasi yang salah dapat memiliki efek negatif:

Kapan Menggunakan: Gunakan untuk kondisi eksepsional atau tidak terduga yang mengganggu alur normal program, seperti:
- Gagalnya operasi I/O (membaca/menulis file, koneksi jaringan).
- Koneksi database terputus.
- Data yang tidak valid dari sumber eksternal (API, file konfigurasi).
- Indeks di luar batas array saat mengakses koleksi data (walaupun seringkali lebih baik divalidasi sebelumnya).
- Kesalahan saat mengurai format data.
Kapan Menghindari: Jangan gunakan exception handling sebagai bagian dari logika kontrol alur program yang normal. Misalnya:
- Validasi input pengguna: Jika Anda mengharapkan pengguna memasukkan angka dan mereka mengetik teks, ini adalah kondisi yang dapat Anda prediksi dan tangani dengan validasi `if-else` atau `TryParse` (misalnya int.TryParse()) daripada melempar `FormatException`.
- Kondisi bisnis normal: Jika saldo pengguna tidak mencukupi, ini bukan 'pengecualian' dalam arti teknis, melainkan kondisi bisnis yang valid yang harus ditangani oleh logika aplikasi, mungkin dengan mengembalikan `false` atau objek hasil khusus.

Dampak Terhadap Performa dan Keamanan

Melempar Pengecualian Sendiri dan Custom Exception

using System;

// Mendefinisikan Custom Exception
public class SaldoTidakCukupException : Exception
{
    public decimal SaldoSaatIni { get; }
    public decimal JumlahPenarikan { get; }

    public SaldoTidakCukupException()
        : base("Saldo tidak mencukupi untuk penarikan ini.") { }

    public SaldoTidakCukupException(string message)
        : base(message) { }

    public SaldoTidakCukupException(string message, Exception innerException)
        : base(message, innerException) { }

    public SaldoTidakCukupException(decimal saldoSaatIni, decimal jumlahPenarikan)
        : base($"Saldo Rp{saldoSaatIni:N0} tidak mencukupi untuk penarikan Rp{jumlahPenarikan:N0}.")
    {
        SaldoSaatIni = saldoSaatIni;
        JumlahPenarikan = jumlahPenarikan;
    }
}

public class AkunBank
{
    private decimal _saldo;

    public AkunBank(decimal saldoAwal) => _saldo = saldoAwal;

    public void TarikDana(decimal jumlah)
    {
        if (jumlah <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(jumlah), "Jumlah penarikan harus lebih besar dari nol.");
        }

        if (_saldo < jumlah)
        {
            throw new SaldoTidakCukupException(_saldo, jumlah); // Melempar custom exception
        }

        _saldo -= jumlah;
        Console.WriteLine($"Penarikan berhasil: Rp{jumlah:N0}. Saldo saat ini: Rp{_saldo:N0}.");
    }
}

public class ContohThrowException
{
    public static void Main(string[] args)
    {
        AkunBank akun = new AkunBank(100000);

        try
        {
            akun.TarikDana(150000); // Ini akan melempar SaldoTidakCukupException
        }
        catch (SaldoTidakCukupException ex)
        {
            Console.WriteLine($"ERROR Penarikan: {ex.Message}");
            Console.WriteLine($"Saldo Anda saat ini: Rp{ex.SaldoSaatIni:N0}.");
            Console.WriteLine($"Anda mencoba menarik: Rp{ex.JumlahPenarikan:N0}.");
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine($"ERROR Input: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Terjadi kesalahan tak terduga: {ex.Message}");
        }

        try
        {
            akun.TarikDana(-50000); // Ini akan melempar ArgumentOutOfRangeException
        }
        catch (Exception ex)
        {
            Console.WriteLine($"ERROR Umum: {ex.Message}");
        }
    }
}

Performa: Proses melempar dan menangkap pengecualian memiliki overhead performa. Meskipun overhead ini umumnya kecil untuk satu atau dua pengecualian, jika Anda secara rutin melempar dan menangkap ribuan pengecualian dalam waktu singkat (misalnya, menggunakannya untuk kontrol alur), ini dapat secara signifikan memengaruhi performa aplikasi Anda. Oleh karena itu, hindari menggunakan exception handling untuk skenario yang dapat dicegah dengan validasi atau pemeriksaan kondisi sederhana.
Keamanan: Penting untuk tidak mengekspos detail pengecualian teknis (seperti StackTrace atau pesan error internal sistem) langsung ke pengguna akhir di lingkungan produksi. Informasi ini bisa digunakan oleh penyerang untuk memahami struktur internal aplikasi Anda dan mencari celah keamanan. Selalu log detail pengecualian ke sistem logging internal Anda untuk debugging, tetapi tampilkan pesan yang ramah pengguna dan umum kepada pengguna.

Best Practice dalam Exception Handling C#

Perbedaan Throw; dan Throw Ex;

using System;

public class ThrowVsThrowEx
{
    public static void MethodA()
    {
        try
        {
            MethodB();
        }
        catch (Exception ex)
        {
            Console.WriteLine("\n--- Menangkap di MethodA ---");
            Console.WriteLine($"Message: {ex.Message}");
            Console.WriteLine($"StackTrace di MethodA:\n{ex.StackTrace}");
            
            // Ini akan mempertahankan stack trace asli
            // throw;

            // Ini akan mengganti stack trace dengan lokasi throw ex di sini
            // throw ex;
        }
    }

    public static void MethodB()
    {
        try
        {
            MethodC();
        }
        catch (Exception ex)
        {
            Console.WriteLine("\n--- Menangkap di MethodB ---");
            Console.WriteLine($"Message: {ex.Message}");
            Console.WriteLine($"StackTrace di MethodB:\n{ex.StackTrace}");
            
            // Contoh 1: Hanya log, lalu lempar kembali dengan mempertahankan stack trace
            Console.WriteLine("Melempar kembali dengan 'throw;'");
            throw; 
        }
    }

    public static void MethodC()
    {
        // Lokasi asli exception
        throw new InvalidOperationException("Ini adalah exception asli dari MethodC");
    }

    public static void Main(string[] args)
    {
        Console.WriteLine("Mendemonstrasikan 'throw;' (mempertahankan stack trace):");
        try
        {
            MethodA();
        }
        catch (Exception finalEx)
        {
            Console.WriteLine("\n--- Menangkap di Main (final) ---");
            Console.WriteLine($"Message: {finalEx.Message}");
            Console.WriteLine($"StackTrace di Main (final):\n{finalEx.StackTrace}");
        }

        Console.WriteLine("\n======================================================");
        Console.WriteLine("Mendemonstrasikan 'throw ex;' (mengganti stack trace):");
        try
        {
            MethodAWithThrowEx();
        }
        catch (Exception finalEx)
        {
            Console.WriteLine("\n--- Menangkap di Main (final) dengan throw ex ---");
            Console.WriteLine($"Message: {finalEx.Message}");
            Console.WriteLine($"StackTrace di Main (final):\n{finalEx.StackTrace}");
        }
    }

    public static void MethodAWithThrowEx()
    {
        try
        {
            MethodBWithThrowEx();
        }
        catch (Exception ex)
        {
            Console.WriteLine("\n--- Menangkap di MethodAWithThrowEx ---");
            Console.WriteLine($"Message: {ex.Message}");
            Console.WriteLine($"StackTrace di MethodAWithThrowEx:\n{ex.StackTrace}");
            
            Console.WriteLine("Melempar kembali dengan 'throw ex;'");
            throw ex; // Perhatikan perbedaan di sini
        }
    }

    public static void MethodBWithThrowEx()
    {
        try
        {
            MethodC();
        }
        catch (Exception ex)
        {
            Console.WriteLine("\n--- Menangkap di MethodBWithThrowEx ---");
            Console.WriteLine($"Message: {ex.Message}");
            Console.WriteLine($"StackTrace di MethodBWithThrowEx:\n{ex.StackTrace}");

            Console.WriteLine("Melempar kembali dengan 'throw ex;'");
            throw ex; // Perhatikan perbedaan di sini
        }
    }
}

Sebagai seorang software engineer senior, saya sering melihat developer pemula membuat beberapa kesalahan umum dalam exception handling. Berikut adalah beberapa praktik terbaik untuk diikuti:

Tangkap Exception Spesifik: Selalu coba menangkap jenis pengecualian yang paling spesifik terlebih dahulu. Ini memungkinkan Anda untuk menangani masalah dengan lebih presisi.
Jangan 'Swallow' Exception: Hindari blok catch kosong (misalnya, catch (Exception) { }). Ini adalah salah satu kesalahan paling fatal karena menyembunyikan masalah dan membuat aplikasi sangat sulit di-debug. Minimal, log pengecualian tersebut.
Log Exception Secara Detail: Pastikan Anda mencatat semua informasi relevan tentang pengecualian (Message, StackTrace, InnerException, waktu, konteks pengguna/transaksi) ke sistem logging Anda. Ini sangat berharga untuk debugging dan pemantauan di produksi.
Gunakan finally untuk Resource Cleanup: Pastikan sumber daya (file, koneksi database) yang dibuka selalu ditutup, terlepas dari terjadinya exception. Atau, gunakan statement using untuk objek IDisposable.
Throw Early, Catch Late: Idealnya, pengecualian harus dilemparkan sedini mungkin ketika kondisi error terdeteksi, tetapi ditangkap di lapisan aplikasi yang lebih tinggi yang memiliki konteks untuk menanganinya (misalnya, lapisan UI atau API). Ini mencegah logika penanganan error tersebar di seluruh kode.
Buat Custom Exceptions: Untuk error yang spesifik untuk domain bisnis Anda, buat kelas pengecualian kustom. Ini meningkatkan kejelasan kode dan memungkinkan pemanggil untuk menangani error bisnis dengan cara yang lebih terstruktur.
Hindari Exception untuk Kontrol Alur: Seperti yang sudah dibahas, jangan gunakan exception sebagai pengganti `if/else` atau mekanisme validasi lainnya.

Kesimpulan

Exception handling dengan try, catch, dan finally adalah salah satu fitur paling fundamental dan krusial dalam membangun aplikasi C# yang robust dan dapat diandalkan. Dengan memisahkan logika penanganan error dari logika bisnis, kita dapat menciptakan kode yang lebih bersih, lebih mudah dikelola, dan memberikan pengalaman pengguna yang lebih baik.

Menguasai kapan dan bagaimana menggunakan mekanisme ini dengan bijak akan membedakan antara developer yang hanya bisa membuat kode yang berjalan, dengan developer yang mampu membangun sistem yang tangguh dan tahan terhadap berbagai skenario tak terduga di lingkungan produksi.

FAQ (Frequently Asked Questions)

Menggunakan `using` statement sebagai alternatif `finally` untuk `IDisposable`

using System;
using System.IO;

public class ContohUsingStatement
{
    public static void Main(string[] args)
    {
        try
        {
            // Menggunakan 'using' statement untuk memastikan StreamReader ditutup
            // meskipun terjadi exception.
            using (StreamReader reader = new StreamReader("test.txt")) 
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    Console.WriteLine(line);
                    // Simulasi operasi yang bisa gagal
                    if (line.Contains("error"))
                    {
                        throw new InvalidOperationException("Baris mengandung kata 'error'.");
                    }
                }
            }
        }
        catch (FileNotFoundException ex)
        {
            Console.WriteLine($"Error: File tidak ditemukan! {ex.Message}");
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine($"Error operasi: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error tak terduga: {ex.Message}");
        }
        // Tidak ada blok finally eksplisit diperlukan untuk menutup reader
        // karena 'using' statement otomatis akan memanggil Dispose().

        Console.WriteLine("Program selesai.");
    }
}

Apa perbedaan antara `throw;` dan `throw ex;`?

throw; (tanpa variabel) akan melempar kembali pengecualian asli sambil mempertahankan stack trace yang lengkap dari titik awal pengecualian terjadi. Ini adalah praktik terbaik saat Anda ingin meneruskan pengecualian ke penanganan yang lebih tinggi setelah mencatatnya. Sebaliknya, throw ex; (dengan variabel ex) akan membuat stack trace baru dari lokasi throw ex;, yang dapat menyembunyikan informasi penting untuk debugging.

Kapan saya harus membuat custom exception saya sendiri?

Anda harus membuat custom exception ketika Anda perlu merepresentasikan kondisi error yang spesifik untuk domain aplikasi Anda dan tidak dapat dijelaskan dengan baik oleh kelas pengecualian standar C#. Ini meningkatkan kejelasan dan memungkinkan kode pemanggil untuk menangani error bisnis dengan cara yang lebih terstruktur dan spesifik.

Apakah penggunaan `try-catch` selalu memengaruhi performa?

Penggunaan blok try-catch itu sendiri memiliki overhead performa yang minimal. Namun, overhead yang signifikan terjadi ketika sebuah pengecualian benar-benar dilempar dan ditangkap. Proses pembuatan objek pengecualian dan pengumpulan stack trace membutuhkan sumber daya. Oleh karena itu, hindari menggunakan pengecualian sebagai mekanisme kontrol alur normal yang dapat terjadi secara sering, dan gunakan validasi atau pengecekan kondisi untuk skenario yang dapat diprediksi.

Apakah saya perlu menambahkan `try-catch` di setiap method?

Tidak, tidak disarankan untuk menambahkan try-catch di setiap method. Praktik terbaik adalah 'throw early, catch late'. Pengecualian harus ditangkap di lapisan aplikasi yang memiliki konteks untuk menanganinya secara bermakna (misalnya, di lapisan UI untuk menampilkan pesan error ke pengguna, atau di lapisan API untuk mengembalikan respons error yang sesuai). Menambahkan try-catch di mana-mana dapat membuat kode Anda menjadi berantakan dan sulit dibaca.

Catatan dari Penulis

Menurut saya, pemahaman yang kokoh tentang exception handling adalah salah satu indikator penting kematangan seorang developer. Saya ingat betul ketika pertama kali mengenal konsep ini, rasanya seperti menemukan 'jaring pengaman' untuk kode yang sebelumnya terasa sangat rapuh. Namun, saya sering melihat developer junior, dengan niat baik, justru membuat kode lebih buruk dengan <code>catch (Exception) { }</code> kosong, yang sejujurnya lebih berbahaya daripada tanpa <code>try-catch</code> sama sekali karena menyembunyikan masalah. Kunci sebenarnya adalah tidak hanya tahu cara menggunakannya, tapi juga tahu kapan dan bagaimana menanganinya dengan bertanggung jawab, sehingga aplikasi bisa gagal dengan elegan tanpa kehilangan data krusial atau menampilkan detail sensitif ke publik.

Seri Belajar C# Fundamental:

← Sebelumnya: Interface vs Abstract Class di C#

→ Selanjutnya: Collectionc Generic List Dictionary dan HashSet

Exception Handling C#: Kuasai Try Catch Finally untuk Kode Robust

Menguasai Exception Handling di C#: Peran Penting Try, Catch, dan Finally

Mengapa Kita Butuh Exception Handling? Sebuah Kebutuhan Fundamental

Memahami Pilar Exception Handling: Try, Catch, dan Finally

Blok try: Melindungi Kode Anda

Blok catch: Menangkap dan Mengelola Pengecualian

Blok finally: Pastikan Aksi Krusial Terlaksana

Melempar Pengecualian Sendiri: throw