Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Pomoc .NET
  4. C# Catch Multiple Exceptions
POMOC .NET

C# — przechwytywanie wielu wyjątków (jak to działa dla programistów)

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
Zaktualizowano:

Prawidłowe obsługiwanie wyjątków jest istotne w C#. Ten samouczek pokazuje, jak używać bloku try-catch z wieloma klauzulami catch. Omówimy, jak złapać wiele typów wyjątków, używać filtrów wyjątków i zapewnić zwalnianie zasobów za pomocą bloku finally. Celem jest pomoc w budowie solidnych i odpornych na błędy aplikacji C#.

Ucząc się łapania różnych typów wyjątków, można dostosować odpowiedzi do specyficznych problemów, poprawiając niezawodność programu. Również omówimy, jak stosować warunki w blokach catch za pomocą słowa kluczowego when, co umożliwia dokładniejszą obsługę błędów.

Ten przewodnik zapewni metody łapania wyjątków i sprawne zarządzanie zarówno zwykłymi, jak i skomplikowanymi błędami w projektach programistycznych. Przyjrzymy się także IronPDF w kontekście obsługi wyjątków.

Co to jest obsługa wyjątków?

Obsługa wyjątków w C# to metoda używana do zarządzania błędami w czasie wykonywania, zapobiegająca nagłemu zakończeniu programu i radzenia sobie z nieoczekiwanymi sytuacjami, gdy wystąpią podczas wykonywania programu. Główne składniki obsługi wyjątków obejmują bloki try, catch i finally.

Podstawowa struktura try-catch w C

Blok try zawiera kod, który potencjalnie może wywołać wyjątek, natomiast blok catch jest odpowiedzialny za zarządzanie wyjątkiem, jeśli wystąpi. Blok finally jest opcjonalny i wykonuje kod po zakończeniu bloków try i catch, niezależnie od tego, czy wyjątek został rzucony czy nie. Oto prosta struktura:

try
{
    // Code that may throw an exception
}
catch (Exception e)
{
    // Code to handle the exception
}
finally
{
    // Code that executes after try and catch, regardless of an exception
}
try
{
    // Code that may throw an exception
}
catch (Exception e)
{
    // Code to handle the exception
}
finally
{
    // Code that executes after try and catch, regardless of an exception
}
Try
	' Code that may throw an exception
Catch e As Exception
	' Code to handle the exception
Finally
	' Code that executes after try and catch, regardless of an exception
End Try
$vbLabelText   $csharpLabel

Łapanie wielu wyjątków

W rzeczywistych aplikacjach pojedyncza operacja może wyrzucać wyjątki różnych typów. Aby to rozwiązać, C# pozwala na zdefiniowanie wielu bloków catch dla jednego bloku try. Każdy blok catch może określić inny typ wyjątku, aby obsłużyć wszystkie wyjątki.

Dlaczego łapać wiele wyjątków?

Łapanie wielu wyjątków jest istotne dla szczegółowego zarządzania błędami, gdzie działania zależą od konkretnego błędu, który wystąpił. To pozwala deweloperom obsługiwać każdy wyjątek w sposób odpowiedni do kontekstu tego konkretnego błędu.

Jak zaimplementować wiele bloków Catch

Oto przykład implementacji pojedynczego bloku catch do łapania wielu typów wyjątków:

try
{
    // Code that may throw multiple types of exceptions
    int[] numbers = { 1, 2, 3 };
    Console.WriteLine(numbers[5]); // This will throw an IndexOutOfRangeException
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("An index was out of range: " + ex.Message);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Can't divide by Zero: " + ex.Message);
}
catch (Exception ex)
{
    Console.WriteLine("Error: " + ex.Message);
}
try
{
    // Code that may throw multiple types of exceptions
    int[] numbers = { 1, 2, 3 };
    Console.WriteLine(numbers[5]); // This will throw an IndexOutOfRangeException
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("An index was out of range: " + ex.Message);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Can't divide by Zero: " + ex.Message);
}
catch (Exception ex)
{
    Console.WriteLine("Error: " + ex.Message);
}
Try
	' Code that may throw multiple types of exceptions
	Dim numbers() As Integer = { 1, 2, 3 }
	Console.WriteLine(numbers(5)) ' This will throw an IndexOutOfRangeException
Catch ex As IndexOutOfRangeException
	Console.WriteLine("An index was out of range: " & ex.Message)
Catch ex As DivideByZeroException
	Console.WriteLine("Can't divide by Zero: " & ex.Message)
Catch ex As Exception
	Console.WriteLine("Error: " & ex.Message)
End Try
$vbLabelText   $csharpLabel

W tym kodzie specyficzne wyjątki, takie jak IndexOutOfRangeException i DivideByZeroException są łapane przez swoje odpowiednie bloki catch. Inne typy wyjątków są łapane przez ogólny blok catch Exception.

Korzystanie z filtrów wyjątków ze słowem kluczowym When

C# obsługuje również filtry wyjątków, które pozwalają na określenie warunku w bloku catch. Ta funkcja wykorzystuje słowo kluczowe when, aby zapewnić większą kontrolę nad tym, które wyjątki łapać, na podstawie warunku ocenianego w czasie wykonywania.

Oto sposób, w jaki można użyć słowa kluczowego when do dodania filtrów wyjątków:

try
{
    // Code that may throw an exception
    throw new InvalidOperationException("Invalid operation occurred", new Exception("Inner exception"));
}
catch (Exception ex) when (ex.InnerException != null)
{
    Console.WriteLine("Exception with inner exception caught: " + ex.Message);
}
catch (Exception ex)
{
    Console.WriteLine("Exception caught: " + ex.Message);
}
try
{
    // Code that may throw an exception
    throw new InvalidOperationException("Invalid operation occurred", new Exception("Inner exception"));
}
catch (Exception ex) when (ex.InnerException != null)
{
    Console.WriteLine("Exception with inner exception caught: " + ex.Message);
}
catch (Exception ex)
{
    Console.WriteLine("Exception caught: " + ex.Message);
}
Try
	' Code that may throw an exception
	Throw New InvalidOperationException("Invalid operation occurred", New Exception("Inner exception"))
Catch ex As Exception When ex.InnerException IsNot Nothing
	Console.WriteLine("Exception with inner exception caught: " & ex.Message)
Catch ex As Exception
	Console.WriteLine("Exception caught: " & ex.Message)
End Try
$vbLabelText   $csharpLabel

Rola bloku Finally

Blok finally służy do wykonania kodu po zakończeniu bloków try i wszelkich bloków catch. Jest przydatny do czyszczenia zasobów, takich jak zamykanie strumieni plików czy połączeń z bazą danych, niezależnie od tego, czy wystąpił wyjątek.

try
{
    // Code that might throw an exception
}
catch (Exception e)
{
    // Handle the exception
}
finally
{
    // Cleanup code, executed after try/catch
    Console.WriteLine("Cleanup code runs here.");
}
try
{
    // Code that might throw an exception
}
catch (Exception e)
{
    // Handle the exception
}
finally
{
    // Cleanup code, executed after try/catch
    Console.WriteLine("Cleanup code runs here.");
}
Try
	' Code that might throw an exception
Catch e As Exception
	' Handle the exception
Finally
	' Cleanup code, executed after try/catch
	Console.WriteLine("Cleanup code runs here.")
End Try
$vbLabelText   $csharpLabel

Wprowadzenie do IronPDF

IronPDF to wszechstronna biblioteka zaprojektowana dla programistów C# pracujących w ramach aplikacji .NET. Pomaga programistom manipulować, zarządzać i tworzyć pliki PDF bezpośrednio z HTML. Nie wymaga zewnętrznych zależności dla działania.

Można wykonywać każdą operację PDF bez użycia i instalacji Adobe Acrobat. IronPDF obsługuje różne funkcje PDF, takie jak edycja, łączenie, dzielenie i zabezpieczanie dokumentów PDF za pomocą szyfrowania i podpisów cyfrowych. Deweloperzy mogą korzystać z IronPDF w różnych typach aplikacji, w tym aplikacjach webowych, desktopowych i usługach.

Interlink:

Kluczową cechą IronPDF jest konwersja HTML na PDF, która zachowuje zarówno układ, jak i styl. To idealne rozwiązanie do tworzenia plików PDF z treści webowych, niezależnie od tego, czy chodzi o raporty, faktury, czy dokumentację. Pliki HTML, adresy URL i ciągi HTML mogą być konwertowane na pliki PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Przykład kodu

Oto prosty przykład w C# z użyciem IronPDF do stworzenia PDF z HTML, z obsługą błędów dla wielu typów wyjątków. Ten przykład zakłada, że masz zainstalowany IronPDF w swoim projekcie. Uruchom to polecenie w konsoli NuGet, aby zainstalować IronPDF:

Install-Package IronPdf

Oto kod:

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Set your IronPDF license key, if applicable.
        License.LicenseKey = "License-Key";
        var renderer = new ChromePdfRenderer();

        try
        {
            // Convert HTML to PDF
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
            pdf.SaveAs("Exceptions.pdf");
            Console.WriteLine("PDF successfully created.");
        }
        catch (IronPdf.Exceptions.IronPdfProductException ex)
        {
            // Handle PDF generation errors
            Console.WriteLine("Failed to generate PDF: " + ex.Message);
        }
        catch (System.IO.IOException ex)
        {
            // Handle IO errors (e.g., disk I/O errors)
            Console.WriteLine("IO Exception: " + ex.Message);
        }
        catch (Exception ex)
        {
            // Handle other errors
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}
using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Set your IronPDF license key, if applicable.
        License.LicenseKey = "License-Key";
        var renderer = new ChromePdfRenderer();

        try
        {
            // Convert HTML to PDF
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
            pdf.SaveAs("Exceptions.pdf");
            Console.WriteLine("PDF successfully created.");
        }
        catch (IronPdf.Exceptions.IronPdfProductException ex)
        {
            // Handle PDF generation errors
            Console.WriteLine("Failed to generate PDF: " + ex.Message);
        }
        catch (System.IO.IOException ex)
        {
            // Handle IO errors (e.g., disk I/O errors)
            Console.WriteLine("IO Exception: " + ex.Message);
        }
        catch (Exception ex)
        {
            // Handle other errors
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}
Imports IronPdf
Imports System

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Set your IronPDF license key, if applicable.
		License.LicenseKey = "License-Key"
		Dim renderer = New ChromePdfRenderer()

		Try
			' Convert HTML to PDF
			Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>")
			pdf.SaveAs("Exceptions.pdf")
			Console.WriteLine("PDF successfully created.")
		Catch ex As IronPdf.Exceptions.IronPdfProductException
			' Handle PDF generation errors
			Console.WriteLine("Failed to generate PDF: " & ex.Message)
		Catch ex As System.IO.IOException
			' Handle IO errors (e.g., disk I/O errors)
			Console.WriteLine("IO Exception: " & ex.Message)
		Catch ex As Exception
			' Handle other errors
			Console.WriteLine("Error: " & ex.Message)
		End Try
	End Sub
End Class
$vbLabelText   $csharpLabel

Kiedy uruchomimy ten kod, wyświetla się ta wiadomość w wierszu poleceń.

C# Łapanie wielu wyjątków (Jak to działa dla programistów): Rysunek 1

I to jest plik PDF wygenerowany przez ten kod:

C# Łapanie wielu wyjątków (Jak to działa dla programistów): Rysunek 2

Upewnij się, że testujesz to w środowisku, w którym IronPDF jest właściwie skonfigurowany, i zmodyfikuj zawartość HTML zgodnie z potrzebami swojej aplikacji. To pomoże ci efektywnie zarządzać błędami, poprawiając niezawodność zadań związanych z generowaniem PDF.

Wnioski

C# Łapanie wielu wyjątków (Jak to działa dla programistów): Rysunek 3

Obsługa wielu wyjątków w C# to potężna funkcjonalność, która zapewnia solidną możliwość obsługi błędów w twoich aplikacjach. Używając wielu bloków catch, filtrów wyjątków i bloku finally, można stworzyć odporną i stabilną aplikację, która z wdziękiem radzi sobie z różnymi błędami i utrzymuje swoją integralność w różnych warunkach błędów.

To dogłębne zrozumienie i wdrożenie obsługi wielu wyjątków zapewnia, że twoje aplikacje są dobrze przygotowane do efektywnego radzenia sobie z nieoczekiwanymi sytuacjami. IronPDF oferuje bezpłatną wersję próbną zaczynając od $799.

Często Zadawane Pytania

Jakie sa zaawansowane techniki zarządzania wyjatkami w C#?

Zaawansowane techniki zarządzania wyjatkami w C# obejmuja używanie wielu bloków catch do obsługi róznych typów wyjatków, stosowanie filtrów wyjatków z użyciem slowa kluczowego when oraz wykorzystanie bloku finally w celu zapewnienia wyczyszczenia zasobów. Te techniki pomagaja w tworzeniu solidnych i odpornych na błędy aplikacji.

Jak można obsługiwac wiele wyjatków w aplikacji C#?

Można obsługiwac wiele wyjatków w aplikacji C# poprzez używanie wielu bloków catch. Kazdy blok catch jest zaprojektowany do obsługi okreslonego typu wyjątku, co pozwala na dostosowane reakcje na rózne scenariusze bledów.

Czym sa filtry wyjatków i jak działaja?

Filtry wyjatków to warunki okreslone w bloku catch za pomoca slowa kluczowego when. Pozwalaja one programistom na przechwytywanie wyjatków na podstawie okreslonych warunków runtime, co zapewnia bardziej precyzyjna kontrole zarządzania bledami.

Jak IronPDF może pomoc w zarzadzaniu wyjatkami podczas generowania plików PDF?

IronPDF może zostac zintegrowany z projektami C# w celu wspomagania generowania plików PDF, jednoczesnie pozwalając programistom na używanie bloków try-catch do zarządzania bledami, które mogą wystapic podczas procesu tworzenia plików PDF. Ta integracja pomaga zapewnic operacje odporne na błędy w aplikacjach.

Dłączego ważne jest zarządzanie zasobami za pomoca bloku finally w C#?

Blok finally jest kluczowy do zarządzania zasobami, takimi jak strumienie plików czy połączenia z baza danych, poniewaz wykonuje kod po blokach try i catch, niezależnie od tego, czy wyjątek zostal rzucony. Zapewnia to prawidlowe wydanie i wyczyszczenie zasobów.

Czy biblioteki C# mogą być używane do generowania plików PDF bez polegania na aplikacjach firm trzecich?

Tak, biblioteki takie jak IronPDF pozwalają na generowanie plików PDF bezpośrednio w ramach aplikacji C#, bez potrzeby korzystania z aplikacji firm trzecich, takich jak Adobe Acrobat. Te biblioteki oferuja funkcjonalność przeksztalcania, edytowania i zarządzania dokumentami PDF.

Jakie jest znaczenie używania wielu bloków catch w zarzadzaniu bledami?

Uzywanie wielu bloków catch w zarzadzaniu bledami pozwala programistom na unikalna obsługę róznych typów wyjatków, poprawiajac szczegółowosc i skuteczność reakcji na błędy oraz czyniac aplikacje bardziej odpornymi na rózne warunki bledów.

Jak programisci mogą poprawić niezawodność swoich projektów w C#?

Programisci mogą zwiększać niezawodność swoich projektów w C# poprzez wdrazanie kompleksowych strategii obsługi wyjatków, takich jak używanie wielu bloków catch, filtrów wyjatków oraz bloków finally, szczególnie w przypadku skomplikówanych zadań, takich jak generowanie plików PDF.

Jacob Mellor, Dyrektor Technologiczny @ Team Iron
Jacob Mellor
  Czat z zespołem inżynierów teraz
Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczą...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie