try catch C#: Menangani Exception dengan catch, when, dan finally

Saat ada yang salah ketika program berjalan (file tidak ada, teks bukan angka, key tidak ada di dictionary), .NET melempar exception: sebuah objek yang menjelaskan error tersebut. Exception naik lewat call stack sampai ada blok catch yang menanganinya. Kalau tidak ada, program berhenti dan mencetak error-nya.

try catch dasar

Bungkus kode yang bisa gagal dengan try, dan tangani kegagalannya di catch:

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { "42", "forty-two", "7" };

        foreach (string input in inputs)
        {
            try
            {
                int n = int.Parse(input);
                Console.WriteLine(input + " doubled is " + (n * 2));
            }
            catch (FormatException)
            {
                Console.WriteLine("'" + input + "' is not a number");
            }
        }
        Console.WriteLine("Still running");
    }
}

Output:

42 doubled is 84
'forty-two' is not a number
7 doubled is 14
Still running

Saat int.Parse("forty-two") melempar exception, Console.WriteLine setelahnya di blok try dilewati, blok catch (FormatException) dijalankan, dan loop berlanjut. Kamu boleh tidak menulis variabel (catch (FormatException)) kalau tidak membutuhkan objek exception-nya.

Untuk kasus ini sebenarnya ada alat yang lebih baik: int.TryParse(input, out int n) mengembalikan false alih-alih melempar exception. Exception ditujukan untuk situasi yang tidak diharapkan oleh kode; input yang sering tidak valid adalah hal yang diharapkan, jadi periksa input itu alih-alih menangkap exception.

Bagaimana exception bergerak

Exception yang dilempar jauh di dalam rantai pemanggilan akan keluar dari setiap method sampai menemukan handler yang cocok. Kode setelah titik throw di setiap method itu tidak dijalankan.

using System;
using System.Collections.Generic;

class Program
{
    static Dictionary<string, decimal> prices = new Dictionary<string, decimal>
    {
        ["tea"] = 2.50m,
    };

    static decimal PriceOf(string item)
    {
        return prices[item];                         // throws for a missing item
    }

    static decimal OrderTotal(string item, int qty)
    {
        decimal total = PriceOf(item) * qty;
        Console.WriteLine("OrderTotal finished");    // skipped when PriceOf throws
        return total;
    }

    static void Main()
    {
        try
        {
            Console.WriteLine(OrderTotal("tea", 2));
            Console.WriteLine(OrderTotal("cake", 1));
            Console.WriteLine("not reached");
        }
        catch (KeyNotFoundException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name + " in Main");
        }
    }
}

Output:

OrderTotal finished
5.00
Caught KeyNotFoundException in Main

PriceOf dan OrderTotal tidak punya catch, jadi exception langsung melewati keduanya menuju Main. Letakkan handler di tingkat yang tahu harus berbuat apa terhadap kegagalan itu, yang sering kali bukan di tempat kegagalan terjadi.

Menangkap exception tertentu dengan urutan yang benar

Klausa catch menangani tipenya dan setiap tipe turunannya. Kalau ada beberapa klausa, klausa pertama yang cocok yang dipakai, jadi urutkan dari yang paling spesifik ke yang paling umum:

using System;

class Program
{
    static void Divide(string a, string b)
    {
        try
        {
            int x = int.Parse(a);
            int y = int.Parse(b);
            Console.WriteLine(a + " / " + b + " = " + (x / y));
        }
        catch (DivideByZeroException)
        {
            Console.WriteLine("Cannot divide by zero");
        }
        catch (FormatException)
        {
            Console.WriteLine("Both values must be whole numbers");
        }
        catch (Exception e)
        {
            Console.WriteLine("Unexpected: " + e.GetType().Name);
        }
    }

    static void Main()
    {
        Divide("10", "2");
        Divide("10", "0");
        Divide("ten", "2");
        Divide("99999999999", "1"); // too large for int
    }
}

Output:

10 / 2 = 5
Cannot divide by zero
Both values must be whole numbers
Unexpected: OverflowException

Pemanggilan terakhir melempar OverflowException, yang tidak ditangani oleh kedua klausa spesifik, jadi catch (Exception e) yang umum yang menanganinya. Kalau catch (Exception) diletakkan pertama, klausa setelahnya tidak akan pernah tercapai, dan compiler menolaknya dengan error CS0160.

Exception filter dengan when

C# 6 menambahkan when: kondisi yang menentukan apakah sebuah klausa catch berlaku. Kalau hasilnya false, runtime terus mencari handler lain seolah klausa itu tidak ada.

using System;

class ApiException : Exception
{
    public int StatusCode { get; }
    public ApiException(int statusCode) : base("HTTP " + statusCode)
    {
        StatusCode = statusCode;
    }
}

class Program
{
    static void Call(int status)
    {
        try
        {
            throw new ApiException(status);
        }
        catch (ApiException e) when (e.StatusCode == 404)
        {
            Console.WriteLine("Not found: show an empty page");
        }
        catch (ApiException e) when (e.StatusCode >= 500)
        {
            Console.WriteLine("Server error " + e.StatusCode + ": retry later");
        }
        catch (Exception e) when (e is ArgumentException || e is FormatException)
        {
            Console.WriteLine("Bad input");
        }
    }

    static void Main()
    {
        Call(404);
        Call(503);
        try
        {
            Call(401); // no clause matches: it propagates
        }
        catch (ApiException e)
        {
            Console.WriteLine("Unhandled by Call: " + e.Message);
        }
    }
}

Output:

Not found: show an empty page
Server error 503: retry later
Unhandled by Call: HTTP 401

Filter memungkinkan kamu bercabang berdasarkan data di dalam exception tanpa menangkap lalu melemparnya ulang. Filter juga cara yang rapi untuk menangani dua tipe yang tidak berhubungan dengan cara yang sama, seperti yang dilakukan klausa ketiga. Filter berjalan sebelum stack di-unwind, jadi debugger atau crash dump tetap menunjukkan keadaan aslinya saat tidak ada filter yang cocok.

finally: kode yang selalu dijalankan

Blok finally dijalankan saat kontrol keluar dari try, entah karena selesai, kembali lebih awal, atau melempar exception. Di sinilah tempat untuk pembersihan. (Satu catatan: kalau exception tidak ditangkap di mana pun, proses bisa berakhir tanpa menjalankannya.)

using System;

class Program
{
    static string Process(int step)
    {
        Console.WriteLine("Open connection");
        try
        {
            if (step == 1) return "returned early";
            if (step == 2) throw new InvalidOperationException();
            return "finished";
        }
        catch (InvalidOperationException)
        {
            return "handled error";
        }
        finally
        {
            Console.WriteLine("Close connection");
        }
    }

    static void Main()
    {
        Console.WriteLine(Process(0));
        Console.WriteLine(Process(1));
        Console.WriteLine(Process(2));
    }
}

Output:

Open connection
Close connection
finished
Open connection
Close connection
returned early
Open connection
Close connection
handled error

Di setiap kasus, "Close connection" dicetak sebelum hasil method sampai ke Main: finally berjalan setelah nilai return dihitung tetapi sebelum method benar-benar kembali. Sebuah try boleh punya finally tanpa catch sama sekali, yang membersihkan resource sambil membiarkan exception terus menuju pemanggil.

Untuk objek yang mengimplementasikan IDisposable (file, stream, koneksi), pernyataan using menuliskan try/finally ini untukmu.

Melempar ulang: throw; vs throw e;

Kadang sebuah blok catch mencatat sesuatu ke log lalu membiarkan exception terus berjalan. Cara kamu melempar ulang menentukan apakah stack trace-nya tetap utuh:

using System;
using System.Runtime.CompilerServices;

class Program
{
    // NoInlining keeps this small method as its own frame in the stack trace.
    [MethodImpl(MethodImplOptions.NoInlining)]
    static void LoadConfig()
    {
        throw new InvalidOperationException("config file missing");
    }

    static void RethrowKeep()
    {
        try { LoadConfig(); }
        catch (InvalidOperationException) { throw; }      // original trace
    }

    static void RethrowReset()
    {
        try { LoadConfig(); }
        catch (InvalidOperationException e) { throw e; }  // trace restarts here
    }

    static void Main()
    {
        try { RethrowKeep(); }
        catch (Exception e)
        {
            Console.WriteLine("throw;   trace mentions LoadConfig: " + e.StackTrace.Contains("LoadConfig"));
        }

        try { RethrowReset(); }
        catch (Exception e)
        {
            Console.WriteLine("throw e; trace mentions LoadConfig: " + e.StackTrace.Contains("LoadConfig"));
        }
    }
}

Output:

throw;   trace mentions LoadConfig: True
throw e; trace mentions LoadConfig: False

throw e; memperlakukan exception seolah baru dilempar dari blok catch, jadi frame di bawahnya, termasuk method tempat error terjadi, hilang dari trace. Selalu lempar ulang dengan throw; saja. (Atribut NoInlining hanya ada karena JIT bisa menggabungkan method sekecil ini ke pemanggilnya, yang akan menyembunyikannya dari kedua trace.)

Untuk menambahkan konteks, bungkus exception dalam exception baru dan kirim yang asli sebagai inner exception: throw new ConfigException("Could not start the app", e);. Inner exception menyimpan stack trace-nya sendiri, dan logger mencetak seluruh rantainya. Cara menulis tipe exception sendiri dibahas di melempar exception.

Objek Exception

Setiap exception diturunkan dari System.Exception. Member yang paling sering dipakai:

Catat e.ToString() ke log, bukan e.Message, kalau kamu ingin mendiagnosis kegagalan nanti: pesannya saja jarang menyebutkan di mana masalahnya. Jangan tampilkan e.ToString() kepada pengguna akhir.

Tipe exception yang umum

NullReferenceException, IndexOutOfRangeException dan InvalidCastException hampir selalu berarti ada bug. Perbaiki kodenya, jangan menangkapnya.

Jangan menelan exception

Blok catch yang kosong menyembunyikan setiap error, termasuk yang tidak kamu duga:

try
{
    SaveOrder(order);
}
catch (Exception)
{
    // nothing: the order silently was not saved
}

Program terus berjalan seolah penyimpanannya berhasil, dan penyebab sebenarnya hilang. Pedoman agar penanganan exception tetap jujur:

• Tangkap hanya yang bisa kamu tangani, di tingkat yang bisa menanganinya.
• Kalau kamu menangkap untuk mencatat log, lempar ulang dengan throw; kecuali program memang bisa lanjut.
• Tangkap Exception hanya di tepi terluar: Main, request handler, loop worker.
• Utamakan TryParse, TryGetValue dan pemeriksaan null daripada exception untuk kasus yang sudah diperkirakan. Melempar exception lambat dibandingkan sebuah pemeriksaan, sedangkan blok try yang tidak melempar apa pun hampir tidak ada biayanya.

Kesalahan umum

• catch (Exception) di urutan pertama. Klausa setelahnya tidak bisa dicapai (CS0160).
• throw e; untuk melempar ulang. Ini menghapus stack trace aslinya; pakai throw;.
• Blok catch kosong. Error lenyap begitu saja; setidaknya catat ke log lalu lempar ulang.
• Memakai exception untuk alur kontrol. Validasi input dengan TryParse alih-alih menangkap FormatException.
• Menampilkan e.Message dari exception framework kepada pengguna. Kata-katanya berbeda antarversi .NET dan ditulis untuk developer.