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.

Dlaczego 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 skomplikowanych zadań, takich jak generowanie plików PDF.

Biblioteka PDF dla C#

Explore IronPDF Bezpłatna próba

HTML do PDF

Online Demo Zobacz wszystkie przykłady kodu %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >

Install-Package IronPdf

AKTUALNOŚCI DLA PROGRAMISTÓW

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

Jacob Mellor

Updated: 21 kwietnia 2026

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 przechwycić wiele typów wyjątków, używać filtrów wyjątków oraz zapewnić zwalnianie zasobów przy użyciu 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. Omówimy również, jak zastosować warunki w blokach catch za pomocą słowa kluczowego when, co umożliwia bardziej precyzyjne zarządzanie błędami.

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.

Basic Structure of Try-Catch in 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ł zgłoszony, 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

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

Ł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 definiować wiele 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

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

W tym kodzie konkretne wyjątki takie jak IndexOutOfRangeException i DivideByZeroException są przechwytywane przez odpowiadające im bloki catch. Wszelkie inne typy wyjątków są przechwytywane 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 używa słowa kluczowego when, aby zapewnić większą kontrolę nad tym, które wyjątki przechwytywać na podstawie warunku ocenianego w czasie wykonania.

Oto jak można użyć słowa kluczowego when, aby dodać filtry 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

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

Rola bloku Finally

Blok finally jest używany do wykonania kodu po wykonaniu bloków try i dowolnych 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

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

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 do 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.

Łącze:

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

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

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:

PM > Install-Package 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

Module Program
    Sub Main(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 Module

Imports IronPdf
Imports System

Module Program
    Sub Main(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 Module

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

C# Catch Multiple Exceptions (Jak to działa dla programistów): Rysunek 1

I to jest plik PDF wygenerowany przez ten kod:

C# Catch Multiple Exceptions (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# Catch Multiple Exceptions (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 oraz bloku finally, można stworzyć odporną i stabilną aplikację, która łagodnie obsługuje różne błędy i zachowuje 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ą od $999.

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ącą ponad 50 osób, obsługującą NASA, Teslę i światowe agencje rządowe.

...

Czytaj więcej