Try/Catch w języku C# (jak to działa dla programistów)

Czym są wyjątki i dlaczego należy je obsługiwać?

W języku C# wyjątek to zdarzenie, które ma miejsce podczas działania programu i zakłóca standardowy przebieg wykonywania instrukcji. W przypadku wystąpienia wyjątku przebieg programu zostaje przekierowany, a jeśli wyjątek nie zostanie obsłużony, program zostanie nagle zakończony.

Obsługa wyjątków to sposób na przewidywanie i zarządzanie tymi zakłócającymi zdarzeniami, umożliwiający programowi odzyskanie sprawności po nieoczekiwanych problemach i kontynuowanie działania zgodnie z zamierzeniami. Korzystając z bloków try i catch, możesz zapewnić, że Twój kod płynnie radzi sobie z błędami i dostarcza użytkownikom sensownych informacji zwrotnych.

Blok Try

Blok try to fragment kodu, który może generować wyjątki. Umieszczając kod w bloku try, informujesz kompilator, że chcesz obsłużyć potencjalne wyjątki, które mogą wystąpić w tym bloku.

Oto podstawowy przykład użycia bloku try:

try
{
    // Code that may generate an exception
}
catch (Exception ex)
{
    // Handle the exception
}

try
{
    // Code that may generate an exception
}
catch (Exception ex)
{
    // Handle the exception
}

Try
	' Code that may generate an exception
Catch ex As Exception
	' Handle the exception
End Try

Blok przechwytujący wyjątki

Instrukcja catch jest używana w połączeniu z blokiem try do obsługi wyjątków. Gdy w bloku try wystąpi wyjątek, wykonanie programu przechodzi do odpowiedniego bloku catch, w którym można określić, jak program ma zareagować na ten wyjątek.

Aby przechwycić wyjątek, należy utworzyć blok catch bezpośrednio po bloku try. Blok catch zazwyczaj zawiera parametr reprezentujący przechwycony wyjątek.

Oto przykład działania instrukcji catch:

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}

Try
	Dim result As Integer = 10 \ 0
Catch ex As DivideByZeroException
	Console.WriteLine("An error occurred: " & ex.Message)
End Try

W tym przykładzie kod wewnątrz bloku try próbuje wykonać dzielenie przez zero, co spowoduje wygenerowanie DivideByZeroException. Blok catch obsługuje następnie wyjątek, wyświetlając komunikat dla użytkownika.

Wiele bloków catch obsługujących różne wyjątki

Czasami blok try może generować różne rodzaje możliwych wyjątków. W takich przypadkach można użyć wielu bloków catch, aby obsłużyć każdy typ wyjątku osobno.

Poniższy przykład ilustruje użycie wielu bloków catch:

try
{
    int[] numbers = new int[7];
    numbers[12] = 70; // This line will throw an exception
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("An index out of range error occurred: " + ex.Message);
}
catch (Exception e)
{
    Console.WriteLine("An unexpected error occurred: " + e.Message);
}

try
{
    int[] numbers = new int[7];
    numbers[12] = 70; // This line will throw an exception
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("An index out of range error occurred: " + ex.Message);
}
catch (Exception e)
{
    Console.WriteLine("An unexpected error occurred: " + e.Message);
}

Try
	Dim numbers(6) As Integer
	numbers(12) = 70 ' This line will throw an exception
Catch ex As IndexOutOfRangeException
	Console.WriteLine("An index out of range error occurred: " & ex.Message)
Catch e As Exception
	Console.WriteLine("An unexpected error occurred: " & e.Message)
End Try

W tym przykładzie kod wewnątrz bloku try próbuje przypisać wartość do indeksu tablicy, który nie istnieje, generując IndexOutOfRangeException. Pierwszy blok catch obsługuje ten konkretny wyjątek, natomiast drugi blok catch przechwytuje wszelkie inne wyjątki, które mogą wystąpić.

Pamiętaj, że w przypadku stosowania wielu bloków catch należy zawsze uporządkować je od najbardziej szczegółowych do najbardziej ogólnych typów wyjątków.

Filtry wyjątków Dodawanie warunków do bloków Catch

Filtry wyjątków pozwalają dodawać warunki do bloków catch, umożliwiając przechwytywanie wyjątków tylko wtedy, gdy spełniony jest określony warunek. Aby użyć filtra wyjątków, dodaj słowo kluczowe when, a po nim warunek w instrukcji catch.

Poniższy przykład ilustruje zastosowanie filtrów wyjątków:

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex) when (ex.Message.Contains("divide"))
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("A different divide by zero error occurred: " + ex.Message);
}

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex) when (ex.Message.Contains("divide"))
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("A different divide by zero error occurred: " + ex.Message);
}

Try
	Dim result As Integer = 10 \ 0
Catch ex As DivideByZeroException When ex.Message.Contains("divide")
	Console.WriteLine("An error occurred: " & ex.Message)
Catch ex As DivideByZeroException
	Console.WriteLine("A different divide by zero error occurred: " & ex.Message)
End Try

W powyższym przykładzie pierwszy blok catch obsłuży DivideByZeroException tylko wtedy, gdy komunikat o wyjątku zawiera słowo "divide". Jeśli warunek nie zostanie spełniony, drugi blok catch zajmie się wyjątkiem.

Blok Finally zapewnia wykonanie kodu

W niektórych przypadkach może zaistnieć potrzeba zapewnienia, że określony fragment kodu zostanie wykonany, niezależnie od tego, czy wystąpi wyjątek, czy nie. Aby to osiągnąć, można użyć bloku finally.

Blok finally jest umieszczony po blokach try i catch i jest zawsze wykonywany, niezależnie od tego, czy wystąpi wyjątek.

Oto przykład ilustrujący użycie bloku finally:

try
{
    int result = 10 / 2;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
    Console.WriteLine("This line will always be executed.");
}

try
{
    int result = 10 / 2;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
    Console.WriteLine("This line will always be executed.");
}

Try
	Dim result As Integer = 10 \ 2
Catch ex As DivideByZeroException
	Console.WriteLine("An error occurred: " & ex.Message)
Finally
	Console.WriteLine("This line will always be executed.")
End Try

W powyższym przykładzie, nawet jeśli kod w bloku try nie wygeneruje wyjątku, blok finally nadal zostanie wykonany.

Wyjątki niestandardowe: dostosowywanie wyjątków do własnych potrzeb

Czasami może zajść potrzeba utworzenia własnych, niestandardowych wyjątków w celu obsługi konkretnych wyjątków w kodzie. Aby to zrobić, możesz utworzyć nową klasę dziedziczącą po klasie Exception.

Oto przykład tworzenia niestandardowego wyjątku:

public class CustomException : Exception
{
    public CustomException(string errorMessage) : base(errorMessage)
    {
    }
}

public class CustomException : Exception
{
    public CustomException(string errorMessage) : base(errorMessage)
    {
    }
}

Public Class CustomException
	Inherits Exception

	Public Sub New(ByVal errorMessage As String)
		MyBase.New(errorMessage)
	End Sub
End Class

Teraz możesz używać tego niestandardowego wyjątku w blokach try i catch w następujący sposób:

try
{
    throw new CustomException("This is a custom exception.");
}
catch (CustomException ex)
{
    Console.WriteLine("A custom exception occurred: " + ex.Message);
}

try
{
    throw new CustomException("This is a custom exception.");
}
catch (CustomException ex)
{
    Console.WriteLine("A custom exception occurred: " + ex.Message);
}

Try
	Throw New CustomException("This is a custom exception.")
Catch ex As CustomException
	Console.WriteLine("A custom exception occurred: " & ex.Message)
End Try

W tym przykładzie blok try generuje instancję CustomException, która jest następnie przechwytywana i obsługiwana przez blok catch.

IronPDF: Integracja funkcji PDF z obsługą wyjątków

Dowiedz się więcej o IronPDF – popularnej bibliotece do tworzenia, edycji i wyodrębniania treści z plików PDF w języku C#. W tej sekcji omówimy, w jaki sposób można zintegrować IronPDF z podejściem do obsługi wyjątków typu try-catch, aby płynnie radzić sobie z potencjalnymi błędami.

Install-Package IronPdf

using IronPdf;
using System;

try
{
    var renderer = new ChromePdfRenderer();
    string html = "Hello, World!";
    PdfDocument PDF = renderer.RenderHtmlAsPdf(html);
    PDF.SaveAs("output.PDF");
    Console.WriteLine("PDF created successfully.");
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

using IronPdf;
using System;

try
{
    var renderer = new ChromePdfRenderer();
    string html = "Hello, World!";
    PdfDocument PDF = renderer.RenderHtmlAsPdf(html);
    PDF.SaveAs("output.PDF");
    Console.WriteLine("PDF created successfully.");
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

Imports IronPdf
Imports System

Try
	Dim renderer = New ChromePdfRenderer()
	Dim html As String = "Hello, World!"
	Dim PDF As PdfDocument = renderer.RenderHtmlAsPdf(html)
	PDF.SaveAs("output.PDF")
	Console.WriteLine("PDF created successfully.")
Catch ex As Exception
	Console.WriteLine("An unexpected error occurred: " & ex.Message)
End Try

using IronPdf;
using System;
using System.IO;

try
{
    string pdfPath = "input.PDF";
    if (File.Exists(pdfPath))
    {
        PdfDocument PDF = PdfDocument.FromFile(pdfPath);
        string extractedText = PDF.ExtractAllText();
        Console.WriteLine("Text extracted successfully: " + extractedText);
    }
    else
    {
        Console.WriteLine("The specified PDF file does not exist.");
    }
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

using IronPdf;
using System;
using System.IO;

try
{
    string pdfPath = "input.PDF";
    if (File.Exists(pdfPath))
    {
        PdfDocument PDF = PdfDocument.FromFile(pdfPath);
        string extractedText = PDF.ExtractAllText();
        Console.WriteLine("Text extracted successfully: " + extractedText);
    }
    else
    {
        Console.WriteLine("The specified PDF file does not exist.");
    }
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

Imports IronPdf
Imports System
Imports System.IO

Try
	Dim pdfPath As String = "input.PDF"
	If File.Exists(pdfPath) Then
		Dim PDF As PdfDocument = PdfDocument.FromFile(pdfPath)
		Dim extractedText As String = PDF.ExtractAllText()
		Console.WriteLine("Text extracted successfully: " & extractedText)
	Else
		Console.WriteLine("The specified PDF file does not exist.")
	End If
Catch ex As Exception
	Console.WriteLine("An unexpected error occurred: " & ex.Message)
End Try