Nie znalazłeś tego, czego szukałeś?
Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Korzystanie z IronPDF
  4. 5 kroków do wygenerowania pliku PDF w języku C# przy użyciu IRON PDF
KORZYSTANIE Z IRONPDF

Generowanie PDF w C# z użyciem IronPDF

Curtis Chau
Curtis Chau
Zaktualizowano:

IronPDF umożliwia programistom C# konwersję HTML do formatu PDF w zaledwie 5 krokach za pomocą prostej aplikacji Windows Forms, wymagającej jedynie instalacji pakietu NuGet i kilku wierszy kodu, aby renderować HTML jako profesjonalne dokumenty PDF.

Programiści C# mogą używać IronPDF do generowania plików PDF z HTML. W tym artykułe proces ten zostanie zilustrowany na przykładzie aplikacji C# Windows Forms utworzonej przy użyciu .NET Framework.

Aby utworzyć projekt w programie Visual Studio 2019, wykonaj poniższe czynności.

Jak utworzyć projekt Visual Studio do generowania plików PDF?

Najpierw otwórz program Visual Studio 2019.

Okno startowe Visual Studio 2019 z opcjami klonowania repozytorium, otwierania projektu lub rozwiązania, otwierania lokalnego folderu lub tworzenia nowego projektu

Kliknij "Utwórz nowy projekt".

Teraz wybierz "Aplikacja Windows Forms" z listy szablonów i naciśnij "Dalej". Pojawi się następujące okno:

Okno dialogowe 'Tworzenie nowego projektu' w Visual Studio pokazujące wybór szablonu aplikacji Windows Forms dla .NET Core na systemy Windows, Linux i macOS

Wpisz nazwę projektu "Tworzenie plików PDF za pomocą IronPDF".

Okno konfiguracji nowego projektu w Visual Studio z nazwą projektu 'Stwórz PDF przy użyciu IronPDF' z wybraną aplikacją Windows Forms (NET Framework) i wersją frameworku 4.7.2

Kliknij przycisk "Utwórz". Projekt zostanie utworzony zgodnie z poniższym opisem.

Środowisko Visual Studio IDE pokazujące pusty Windows Form w widoku projektowania z Eksploratorem rozwiązań wyświetlającym nowy projekt o nazwie 'Stwórz PDF przy użyciu IronPDF'

Dlaczego w tym samouczku warto używać Windows Forms?

Windows Forms zapewnia proste środowisko wizualne dla początkujących, którzy uczą się generowania plików PDF w języku C#. Oferuje kreator typu "przeciągnij i upuść", który ułatwia tworzenie interfejsów użytkownika bez konieczności posiadania rozległej wiedzy z zakresu HTML lub tworzenia stron internetowych. Model programowania sterowanego zdarzeniami w Windows Forms dobrze wpisuje się w sposób, w jaki młodsi programiści postrzegają przebieg aplikacji, co czyni go idealnym do demonstracji podstawowych możliwości IronPDF w zakresie konwersji HTML do PDF.

W przypadku aplikacji produkcyjnych warto rozważyć wykorzystanie .NET Core do generowania plików PDF w sieci WWW lub aplikacji konsolowych do przetwarzania wsadowego. Jednak Windows Forms pozostaje doskonałym wyborem dla narzędzi wewnętrznych, programów użytkowych na komputery stacjonarne oraz środowisk edukacyjnych, w których podczas tworzenia oprogramowania potrzebna jest szybka informacja zwrotna w formie wizualnej.

Która wersja Visual Studio działa najlepiej?

Visual Studio 2019 lub nowsze zapewnia najlepsze wrażenia podczas tworzenia oprogramowania z wykorzystaniem IronPDF. Te wersje zawierają ulepszone zarządzanie pakietami NuGet, lepsze wsparcie IntelliSense dla nowoczesnych funkcji C# oraz ulepszone możliwości debugowania, które pomagają podczas rozwiązywania problemów z generowaniem PDF.

Chociaż Visual Studio 2022 oferuje najnowsze funkcje i ulepszenia wydajności, Visual Studio 2019 pozostaje szeroko stosowane i w pełni obsługiwane. Obie wersje działają płynnie z pakietami NuGet firmy IronPDF. Programiści korzystający z Visual Studio Code nadal mogą pracować z IronPDF, choć będą musieli używać interfejsu wiersza poleceń do zarządzania pakietami i zrezygnować z niektórych funkcji projektowania wizualnego przedstawionych w tym samouczku.

Czy mogę używać .NET Core zamiast .NET Framework?

Oczywiście! IronPDF w pełni obsługuje .NET Core, .NET 5, .NET 6 i .NET 7+. W rzeczywistości korzystanie z .NET Core lub nowszych wersji oferuje kilka zalet, w tym kompatybilność międzyplatformową, lepszą wydajność oraz dostęp do najnowszych funkcji języka C#.

Aby korzystać z .NET Core, wystarczy wybrać odpowiednią platformę docelową podczas tworzenia projektu. Przykłady kodu w tym samouczku działają identycznie we wszystkich obsługiwanych frameworkach. Aby zapewnić elastyczność wdrożenia, aplikacje .NET Core mogą działać nie tylko w systemie Windows, ale także w systemach Linux i macOS, co czyni je idealnymi do wdrożeń w chmurze i środowiskach kontenerowych.

Jak zainstalować IronPDF za pomocą menedżera pakietów NuGet?

  • Najpierw kliknij przycisk "Narzędzia" na pasku menu.
  • Otworzy się menu. Teraz kliknij opcję NuGet Package Manager.
  • Otworzy się kolejne podmenu. Teraz kliknij opcję o nazwie Package Manager Console.

Visual Studio z rozwiniętym menu Narzędzia z podmenu Menedżer pakietów NuGet, z podświetloną opcją Konsoli Menedżera Pakietów

Zostaniesz przeniesiony do nowego ekranu z wiersza poleceń. W nim wpisz polecenie do zainstalowania pakietu IronPDF.

Install-Package IronPdf

Środowisko Visual Studio 2019 IDE pokazujące Konsolę Menedżera Pakietów z gotową do wykonania komendą instalacji IronPDF

Naciśnij klawisz Enter po wpisaniu polecenia. Upewnij się, że Twój komputer/laptop jest podłączony do Internetu. Pakiet IronPDF zostanie automatycznie dodany do istniejącego projektu.

Środowisko Visual Studio 2019 IDE pokazujące dokumentację biblioteki IronPDF z przykładem kodu C# dla konwersji HTML do PDF, obok Konsoli Menedżera Pakietów wyświetlającej pomyślną instalację IronPDF

Powyższy ekran pokazuje pakiet pomyślnie dodany do projektu.

Jakie są alternatywne sposoby instalacji IronPDF?

Oprócz konsoli menedżera pakietów masz kilka opcji instalacji IronPDF:

  1. Interfejs użytkownika menedżera pakietów NuGet: Kliknij prawym przyciskiem myszy na swój projekt, wybierz "Zarządzaj pakietami NuGet", wyszukaj "IronPDF" i kliknij "Zainstaluj". Świetne rozwiązanie dla początkujących, którzy preferują interfejsy graficzne.

  2. PackageReference w .csproj: W przypadku nowoczesnych projektów .NET, można dodać IronPDF bezpośrednio do pliku projektu:

    <PackageReference Include="IronPdf" Version="*" />
    <PackageReference Include="IronPdf" Version="*" />
    XML

  3. .NET CLI: Dla deweloperów, którzy preferują narzędzia wiersza poleceń lub używają Visual Studio Code:

    dotnet add package IronPdf
  4. Pobieranie ręczne: Można pobrać bibliotekę DLL bezpośrednio ze strony internetowej IronPDF i dodać ją jako odwołanie, choć takie podejście utrudnia aktualizacje.

Dlaczego podczas instalacji potrzebne jest połączenie z Internetem?

NuGet wymaga połączenia z Internetem, aby pobrać IronPDF i jego zależności z repozytorium NuGet.org. Pakiet zawiera podstawową bibliotekę IronPDF oraz pliki binarne silnika renderującego Chrome niezbędne do konwersji HTML na PDF.

W przypadku instalacji offline można:

Należy pamiętać, że silnik renderujący IronPDF wymaga dodatkowych komponentów uruchomieniowych, które mogą zostać pobrane przy pierwszym użyciu, dlatego podczas początkowego generowania plików PDF zalecane jest połączenie z Internetem.

Jak mogę sprawdzić, czy instalacja przebiegła pomyślnie?

Po instalacji sprawdź, czy IronPDF działa poprawnie, zwracając uwagę na następujące wskaźniki:

  1. Węzeł Referencje: W Eksploratorze rozwiązań rozwiń węzeł Referencje. Powinieneś zobaczyć "IronPDF" wymienione wśród odwołań do projektu.

  2. Wsparcie IntelliSense: Wpisz using IronPdf; na górze pliku C#. IntelliSense powinno rozpoznać przestrzeń nazw bez błędów.

  3. Prosty kod testowy: Dodaj ten podstawowy test, aby zweryfikować funkcjonalność: 
    
using IronPdf;
    
using IronPdf;
    Imports IronPdf
    $vbLabelText   $csharpLabel

// Quick verification test var renderer = new ChromePdfRenderer(); var pdf = renderer.RenderHtmlAsPdf("

Test

"); // If no exceptions occur, IronPDF is installed correctly


4. **Menedżer pakietów**: Uruchom `Get-Package IronPdf` w Konsoli Menedżera Pakietów, aby zobaczyć informacje o wersji.

W razie problemów zapoznaj się z [przewodnikiem](/troubleshooting/quick-ironpdf-troubleshooting/) [dotyczącym rozwiązywania problemów](/troubleshooting/quick-ironpdf-troubleshooting/) lub sprawdź, czy Twój [system spełnia wymagania](/get-started/windows/).

## Jak zaprojektować interfejs użytkownika do generowania plików PDF?

Teraz dodaj etykietę i ustaw tekst na "Utwórz plik PDF z HTML za pomocą IronPDF".

![Środowisko Visual Studio IDE z aplikacją Windows Forms z projektantem formularzy pokazującym etykietę z napisem 'Stwórz PDF z HTML przy użyciu IronPDF'](/static-assets/pdf/blog/5-steps-to-generate-a-pdf-file-in-c-sharp/5-steps-to-generate-a-pdf-file-in-c-sharp-8.webp)

Następnie dodaj pole tekstowe Rich Text Box i przycisk z panelu narzędzi. Ustaw tekst przycisku na "Konwertuj".

![Interfejs aplikacji Windows Form pokazujący pole tekstowe i przycisk Konwertuj do tworzenia PDF z HTML przy użyciu IronPDF](/static-assets/pdf/blog/5-steps-to-generate-a-pdf-file-in-c-sharp/5-steps-to-generate-a-pdf-file-in-c-sharp-9.webp)

### Dlaczego używać `RichTextBox` zamiast zwykłego `TextBox`?

`RichTextBox` oferuje kilka zalet dla [danych wejściowych HTML w scenariuszach generowania PDF](/how-to/html-string-to-pdf/):

1. **Wsparcie dla wielu linii**: HTML zazwyczaj obejmuje wiele linii, a `RichTextBox` obsługuje to naturalnie, podczas gdy `TextBox` wymaga ustawienia Multiline = true.

2. **Zachowanie formatowania**: Podczas gdy wprowadzamy zwykły HTML, `RichTextBox` zachowuje formatowanie, takie jak wcięcia i znaki nowej linii, co sprawia, że HTML jest bardziej czytelny podczas tworzenia.

3. **Większa pojemność**: `RichTextBox` może obsługiwać większe ilości tekstu, co jest przydatne przy pracy z pełnymi dokumentami HTML zamiast fragmentami.

4. **Potencjalne podświetlanie składni**: Chociaż nie jest to zaimplementowane w tym prostym przykładzie, `RichTextBox` można rozszerzyć o [podświetlanie składni dla HTML](/tutorials/pixel-perfect-html-to-pdf/), poprawiając doświadczenie dewelopera.

W przypadku aplikacji produkcyjnych warto rozważyć użycie dedykowanego kontrolki edytora HTML lub integrację z zewnętrznymi edytorami, aby zapewnić użytkownikom lepsze wrażenia.

### Jakie inne elementy sterujące mogłyby ulepszyć interfejs użytkownika?

Aby stworzyć bardziej niezawodną aplikację do generowania plików PDF, rozważ dodanie następujących elementów sterujących:

1. **`WebBrowser` Kontrola**: Wyświetlaj podgląd HTML przed konwersją, pomagając użytkownikom zobaczyć, jak będzie wyglądał ich PDF. To naśladuje [silnik renderowania Chrome IronPDF](/how-to/pixel-perfect-html-to-pdf/).

2. **`ProgressBar`**: Pokazuj postęp konwersji dla dużych dokumentów lub [operacji zbiorczych](/how-to/async/).

3. **`ComboBox` dla szablonów**: Dostarczaj wstępnie zdefiniowane szablony HTML dla typowych dokumentów, takich jak faktury czy raporty.

4. **`PropertyGrid`**: Pozwól użytkownikom modyfikować [ustawienia renderowania PDF](/how-to/custom-paper-size/), takie jak rozmiar strony, marginesy i orientacja.

5. **`TabControl`**: Podziel dane wejściowe HTML, podgląd i [ustawienia PDF](/how-to/rendering-options/) na zorganizowane zakładki.

Przykład dodania paska stanu do informacji zwrotnej:
```csharp
// Add to your form
StatusStrip statusStrip = new StatusStrip();
ToolStripStatusLabel statusLabel = new ToolStripStatusLabel("Ready");
statusStrip.Items.Add(statusLabel);
this.Controls.Add(statusStrip);

Jak nazwać moje kontrolki zgodnie z najlepszymi praktykami?

Stosowanie spójnych konwencji nazewniczych poprawia czytelność kodu i ułatwia jego utrzymanie. Oto zalecane praktyki dotyczące formularza generowania plików PDF:

  1. Użyj opisowych prefiksów:

    • txtHtml dla danych wejściowych HTML RichTextBox
    • btnConvert dla przycisku Konwertuj
    • lblTitle dla etykiety tytułowej

  2. Bądź konsekwentny: Wybierz either camelCase lub PascalCase i trzymaj się tego w całym projekcie.

  3. Unikaj domyślnych nazw: Zastąp richTextBox1 znaczącymi nazwami, takimi jak rtbHtmlInput.

  4. Grupowanie powiązanych elementów sterujących: W przypadku złożonych formularzy należy stosować prefiksy grupujące funkcje:

    • pdfPageSize, pdfOrientation dla ustawień specyficznych dla PDF
    • htmlTemplate, htmlPreview dla kontrolowanych związanych z HTML
  5. Rozważ dostępność: Ustaw właściwość Name dla czytników ekranowych i AccessibleName dla lepszej użyteczności.

Dobre nazewnictwo sprawia, że kod jest samodokumentujący się i pomaga przy wdrażaniu funkcji takich jak ekstrakcja danych z formularzy.

Jak napisać kod do konwersji HTML na PDF?

Kliknij dwukrotnie przycisk "Konwertuj". Otworzy się okno kodu z przyciskiem konwersji.

Środowisko Visual Studio IDE pokazujące kod C# dla Windows Forms z częściową klasą Form1 zawierającą pusty zarządzający zdarzeniem btnConvert_Click do tworzenia PDF-ów przy użyciu IronPDF

Dodaj kod importowania biblioteki IronPDF na górze pliku .cs.

Najpierw dodaj poniższy kod, aby korzystać z metod biblioteki IronPDF.

using IronPdf;
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Poniżej znajduje się początkowy kod do zdarzenia btnConvert_Click, który jest obecnie pusty:

private void btnConvert_Click(object sender, EventArgs e)
{

}
private void btnConvert_Click(object sender, EventArgs e)
{

}
Private Sub btnConvert_Click(ByVal sender As Object, ByVal e As EventArgs)

End Sub
$vbLabelText   $csharpLabel

Teraz napisz następujący kod w zdarzeniu kliknięcia przycisku:

private void btnConvert_Click(object sender, EventArgs e)
{
    // Declare an HtmlToPdf object
    var HtmlLine = new HtmlToPdf();

    // Get HTML text from the user
    string strHtml = txtHtml.Text;

    // Create SaveFileDialog to choose the save path for the PDF file
    SaveFileDialog saveFileDialog = new SaveFileDialog
    {
        InitialDirectory = @"D:\",
        Title = "Save PDF",
        CheckPathExists = true,
        DefaultExt = "pdf",
        Filter = "pdf files (*.pdf)|*.pdf",
        FilterIndex = 2,
        RestoreDirectory = true
    };

    // If the user presses Save
    if (saveFileDialog.ShowDialog() == DialogResult.OK)
    {
        // Get the file path from the user
        string filePath = saveFileDialog.FileName;

        // Convert HTML to PDF and save at the specified path
        using var PDF = HtmlLine.RenderHtmlAsPdf(strHtml);
        PDF.SaveAs(filePath);

        // Clear the TextBox and show a message confirming the successful creation
        txtHtml.Text = "";
        MessageBox.Show("File created successfully.");
    }
}
private void btnConvert_Click(object sender, EventArgs e)
{
    // Declare an HtmlToPdf object
    var HtmlLine = new HtmlToPdf();

    // Get HTML text from the user
    string strHtml = txtHtml.Text;

    // Create SaveFileDialog to choose the save path for the PDF file
    SaveFileDialog saveFileDialog = new SaveFileDialog
    {
        InitialDirectory = @"D:\",
        Title = "Save PDF",
        CheckPathExists = true,
        DefaultExt = "pdf",
        Filter = "pdf files (*.pdf)|*.pdf",
        FilterIndex = 2,
        RestoreDirectory = true
    };

    // If the user presses Save
    if (saveFileDialog.ShowDialog() == DialogResult.OK)
    {
        // Get the file path from the user
        string filePath = saveFileDialog.FileName;

        // Convert HTML to PDF and save at the specified path
        using var PDF = HtmlLine.RenderHtmlAsPdf(strHtml);
        PDF.SaveAs(filePath);

        // Clear the TextBox and show a message confirming the successful creation
        txtHtml.Text = "";
        MessageBox.Show("File created successfully.");
    }
}
Private Sub btnConvert_Click(ByVal sender As Object, ByVal e As EventArgs)
	' Declare an HtmlToPdf object
	Dim HtmlLine = New HtmlToPdf()

	' Get HTML text from the user
	Dim strHtml As String = txtHtml.Text

	' Create SaveFileDialog to choose the save path for the PDF file
	Dim saveFileDialog As New SaveFileDialog With {
		.InitialDirectory = "D:\",
		.Title = "Save PDF",
		.CheckPathExists = True,
		.DefaultExt = "pdf",
		.Filter = "pdf files (*.pdf)|*.pdf",
		.FilterIndex = 2,
		.RestoreDirectory = True
	}

	' If the user presses Save
	If saveFileDialog.ShowDialog() = DialogResult.OK Then
		' Get the file path from the user
		Dim filePath As String = saveFileDialog.FileName

		' Convert HTML to PDF and save at the specified path
		Dim PDF = HtmlLine.RenderHtmlAsPdf(strHtml)
		PDF.SaveAs(filePath)

		' Clear the TextBox and show a message confirming the successful creation
		txtHtml.Text = ""
		MessageBox.Show("File created successfully.")
	End If
End Sub
$vbLabelText   $csharpLabel

Wyjaśnienie:

  • Obiekt HtmlToPdf jest tworzony do wykorzystania możliwości konwersji IronPDF.
  • Dane wejściowe HTML są pobierane z pola tekstowego.
  • SaveFileDialog jest używany do monitowania użytkownika o określenie, gdzie ma być zapisany wynikowy plik PDF.
  • Jeśli użytkownik wybierze lokalizację pliku i naciśnie przycisk Zapisz, ścieżka zostanie pobrana.
  • Dane wejściowe HTML są następnie renderowane do PDF przy użyciu RenderHtmlAsPdf i zapisywane na wybranej ścieżce.
  • Po zapisaniu pole tekstowe jest czyszczone, a na ekranie pojawia się okno z komunikatem potwierdzającym utworzenie pliku PDF.

Jakie obsługa błędów powinienem dodać do tego kodu?

Solidna obsługa błędów ma kluczowe znaczenie dla aplikacji do generowania plików PDF w środowisku produkcyjnym. Oto ulepszona wersja z kompleksową obsługą błędów:

private void btnConvert_Click(object sender, EventArgs e)
{
    try
    {
        // Validate input
        if (string.IsNullOrWhiteSpace(txtHtml.Text))
        {
            MessageBox.Show("Please enter HTML content.", "Validation Error", 
                MessageBoxButtons.OK, MessageBoxIcon.Warning);
            return;
        }

        var renderer = new ChromePdfRenderer();
        string strHtml = txtHtml.Text;

        SaveFileDialog saveFileDialog = new SaveFileDialog
        {
            InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
            Title = "Save PDF",
            CheckPathExists = true,
            DefaultExt = "pdf",
            Filter = "pdf files (*.pdf)|*.pdf",
            FilterIndex = 1,
            RestoreDirectory = true
        };

        if (saveFileDialog.ShowDialog() == DialogResult.OK)
        {
            try
            {
                // Show progress cursor
                Cursor.Current = Cursors.WaitCursor;

                using var pdf = renderer.RenderHtmlAsPdf(strHtml);
                pdf.SaveAs(saveFileDialog.FileName);

                txtHtml.Text = "";
                MessageBox.Show("PDF created successfully!", "Success", 
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (IronPdf.Exceptions.IronPdfProductException ex)
            {
                // Handle licensing issues
                MessageBox.Show($"Licensing error: {ex.Message}", "License Error", 
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                Cursor.Current = Cursors.Default;
            }
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show($"An error occurred: {ex.Message}", "Error", 
            MessageBoxButtons.OK, MessageBoxIcon.Error);
        // Log the full exception for debugging
        System.Diagnostics.Debug.WriteLine(ex.ToString());
    }
}
private void btnConvert_Click(object sender, EventArgs e)
{
    try
    {
        // Validate input
        if (string.IsNullOrWhiteSpace(txtHtml.Text))
        {
            MessageBox.Show("Please enter HTML content.", "Validation Error", 
                MessageBoxButtons.OK, MessageBoxIcon.Warning);
            return;
        }

        var renderer = new ChromePdfRenderer();
        string strHtml = txtHtml.Text;

        SaveFileDialog saveFileDialog = new SaveFileDialog
        {
            InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
            Title = "Save PDF",
            CheckPathExists = true,
            DefaultExt = "pdf",
            Filter = "pdf files (*.pdf)|*.pdf",
            FilterIndex = 1,
            RestoreDirectory = true
        };

        if (saveFileDialog.ShowDialog() == DialogResult.OK)
        {
            try
            {
                // Show progress cursor
                Cursor.Current = Cursors.WaitCursor;

                using var pdf = renderer.RenderHtmlAsPdf(strHtml);
                pdf.SaveAs(saveFileDialog.FileName);

                txtHtml.Text = "";
                MessageBox.Show("PDF created successfully!", "Success", 
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (IronPdf.Exceptions.IronPdfProductException ex)
            {
                // Handle licensing issues
                MessageBox.Show($"Licensing error: {ex.Message}", "License Error", 
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                Cursor.Current = Cursors.Default;
            }
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show($"An error occurred: {ex.Message}", "Error", 
            MessageBoxButtons.OK, MessageBoxIcon.Error);
        // Log the full exception for debugging
        System.Diagnostics.Debug.WriteLine(ex.ToString());
    }
}
Private Sub btnConvert_Click(sender As Object, e As EventArgs) Handles btnConvert.Click
    Try
        ' Validate input
        If String.IsNullOrWhiteSpace(txtHtml.Text) Then
            MessageBox.Show("Please enter HTML content.", "Validation Error", MessageBoxButtons.OK, MessageBoxIcon.Warning)
            Return
        End If

        Dim renderer As New ChromePdfRenderer()
        Dim strHtml As String = txtHtml.Text

        Dim saveFileDialog As New SaveFileDialog With {
            .InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
            .Title = "Save PDF",
            .CheckPathExists = True,
            .DefaultExt = "pdf",
            .Filter = "pdf files (*.pdf)|*.pdf",
            .FilterIndex = 1,
            .RestoreDirectory = True
        }

        If saveFileDialog.ShowDialog() = DialogResult.OK Then
            Try
                ' Show progress cursor
                Cursor.Current = Cursors.WaitCursor

                Using pdf = renderer.RenderHtmlAsPdf(strHtml)
                    pdf.SaveAs(saveFileDialog.FileName)
                End Using

                txtHtml.Text = ""
                MessageBox.Show("PDF created successfully!", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information)
            Catch ex As IronPdf.Exceptions.IronPdfProductException
                ' Handle licensing issues
                MessageBox.Show($"Licensing error: {ex.Message}", "License Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
            Finally
                Cursor.Current = Cursors.Default
            End Try
        End If
    Catch ex As Exception
        MessageBox.Show($"An error occurred: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
        ' Log the full exception for debugging
        System.Diagnostics.Debug.WriteLine(ex.ToString())
    End Try
End Sub
$vbLabelText   $csharpLabel

Kluczowe ulepszenia w zakresie obsługi błędów:

  • Sprawdzanie poprawności danych wejściowych przed przetworzeniem
  • Specjalne postępowanie w przypadku wyjątków dotyczących licencji IronPDF
  • Wskazanie postępu poprzez zmiany kursora
  • Prawidłowe rejestrowanie wyjątków na potrzeby debugowania
  • Przyjazne dla użytkownika komunikaty o błędach

Jak mogę dostosować ustawienia pliku PDF, takie jak rozmiar strony?

IronPDF zapewnia szerokie możliwości dostosowywania poprzez klasę ChromePdfRenderOptions. Oto jak wdrożyć typowe dostosowania:

private void ConvertWithCustomSettings()
{
    var renderer = new ChromePdfRenderer();

    // Configure rendering options
    renderer.RenderingOptions = new ChromePdfRenderOptions
    {
        // Page setup
        PaperSize = PdfPaperSize.A4,
        PaperOrientation = PdfPaperOrientation.Portrait,
        MarginTop = 25,    // millimeters
        MarginBottom = 25,
        MarginLeft = 20,
        MarginRight = 20,

        // Rendering behavior
        EnableJavaScript = true,
        RenderDelay = 500, // milliseconds
        CreatePdfFormsFromHtml = true,

        // Headers and footers
        TextHeader = new TextHeaderFooter
        {
            CenterText = "My Document",
            FontSize = 12,
            DrawDividerLine = true
        },
        TextFooter = new TextHeaderFooter
        {
            RightText = "Page {page} of {total-pages}",
            FontSize = 10
        }
    };

    // Apply custom CSS for print
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

    // Generate PDF with custom settings
    var pdf = renderer.RenderHtmlAsPdf(txtHtml.Text);
    pdf.SaveAs("custom-output.pdf");
}
private void ConvertWithCustomSettings()
{
    var renderer = new ChromePdfRenderer();

    // Configure rendering options
    renderer.RenderingOptions = new ChromePdfRenderOptions
    {
        // Page setup
        PaperSize = PdfPaperSize.A4,
        PaperOrientation = PdfPaperOrientation.Portrait,
        MarginTop = 25,    // millimeters
        MarginBottom = 25,
        MarginLeft = 20,
        MarginRight = 20,

        // Rendering behavior
        EnableJavaScript = true,
        RenderDelay = 500, // milliseconds
        CreatePdfFormsFromHtml = true,

        // Headers and footers
        TextHeader = new TextHeaderFooter
        {
            CenterText = "My Document",
            FontSize = 12,
            DrawDividerLine = true
        },
        TextFooter = new TextHeaderFooter
        {
            RightText = "Page {page} of {total-pages}",
            FontSize = 10
        }
    };

    // Apply custom CSS for print
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

    // Generate PDF with custom settings
    var pdf = renderer.RenderHtmlAsPdf(txtHtml.Text);
    pdf.SaveAs("custom-output.pdf");
}
Private Sub ConvertWithCustomSettings()
    Dim renderer = New ChromePdfRenderer()

    ' Configure rendering options
    renderer.RenderingOptions = New ChromePdfRenderOptions With {
        ' Page setup
        .PaperSize = PdfPaperSize.A4,
        .PaperOrientation = PdfPaperOrientation.Portrait,
        .MarginTop = 25,    ' millimeters
        .MarginBottom = 25,
        .MarginLeft = 20,
        .MarginRight = 20,

        ' Rendering behavior
        .EnableJavaScript = True,
        .RenderDelay = 500, ' milliseconds
        .CreatePdfFormsFromHtml = True,

        ' Headers and footers
        .TextHeader = New TextHeaderFooter With {
            .CenterText = "My Document",
            .FontSize = 12,
            .DrawDividerLine = True
        },
        .TextFooter = New TextHeaderFooter With {
            .RightText = "Page {page} of {total-pages}",
            .FontSize = 10
        }
    }

    ' Apply custom CSS for print
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print

    ' Generate PDF with custom settings
    Dim pdf = renderer.RenderHtmlAsPdf(txtHtml.Text)
    pdf.SaveAs("custom-output.pdf")
End Sub
$vbLabelText   $csharpLabel

Aby uzyskać bardziej zaawansowane opcje dostosowywania, zapoznaj się z niestandardowymi rozmiarami papieru, niestandardowymi marginesami i ustawieniami okna wyświetlania.

Dlaczego warto używać instrukcji Using do generowania plików PDF?

Instrukcja using jest niezbędna dla właściwego zarządzania zasobami podczas generowania PDF:

  1. Automatyczne usuwanie: Dokumenty PDF mogą zajmować dużo pamięci, zwłaszcza jeśli zawierają obrazy lub duże ilości treści. Instrukcja using zapewnia prawidłowe usunięcie obiektu PDF po użyciu.

  2. Zwolnienie uchwytu pliku: Bez odpowiedniego zwolnienia uchwyty plików mogą pozostać zablokowane, uniemożliwiając dalsze operacje na pliku PDF.

  3. Zarządzanie pamięcią: silnik renderujący IronPDF wykorzystuje zasoby natywne, które muszą zostać zwolnione, aby zapobiec wyciekom pamięci w długo działających aplikacjach.

Oto porównanie wzorców:

// Recommended approach with using
using (var pdf = renderer.RenderHtmlAsPdf(html))
{
    pdf.SaveAs("output.pdf");
} // Resources automatically released here

// Alternative with try-finally (more verbose)
PdfDocument pdf = null;
try
{
    pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
finally
{
    pdf?.Dispose();
}
// Recommended approach with using
using (var pdf = renderer.RenderHtmlAsPdf(html))
{
    pdf.SaveAs("output.pdf");
} // Resources automatically released here

// Alternative with try-finally (more verbose)
PdfDocument pdf = null;
try
{
    pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
finally
{
    pdf?.Dispose();
}
' Recommended approach with Using
Using pdf = renderer.RenderHtmlAsPdf(html)
    pdf.SaveAs("output.pdf")
End Using ' Resources automatically released here

' Alternative with Try-Finally (more verbose)
Dim pdf As PdfDocument = Nothing
Try
    pdf = renderer.RenderHtmlAsPdf(html)
    pdf.SaveAs("output.pdf")
Finally
    If pdf IsNot Nothing Then
        pdf.Dispose()
    End If
End Try
$vbLabelText   $csharpLabel

Dla operacji asynchronicznych, użyj await using w C# 8.0+:

await using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
await using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
Await Using pdf = Await renderer.RenderHtmlAsPdfAsync(html)
$vbLabelText   $csharpLabel

Jakie popularne tagi HTML sprawdzają się najlepiej?

Silnik renderujący IronPDF dla przeglądarki Chrome obsługuje wszystkie nowoczesne tagi HTML5, ale niektóre z nich sprawdzają się szczególnie dobrze przy generowaniu plików PDF:

Struktura dokumentu:

<html>
<head>
    <meta charset="UTF-8">
    <style>
        @media print { /* PDF-specific styles */ }
        body { font-family: Arial, sans-serif; }
        .page-break { page-break-after: always; }
    </style>
</head>
<body>
    <h1>Document Title</h1>
    <div class="page-break"></div>
    <h2>New Page Content</h2>
</body>
</html>
<html>
<head>
    <meta charset="UTF-8">
    <style>
        @media print { /* PDF-specific styles */ }
        body { font-family: Arial, sans-serif; }
        .page-break { page-break-after: always; }
    </style>
</head>
<body>
    <h1>Document Title</h1>
    <div class="page-break"></div>
    <h2>New Page Content</h2>
</body>
</html>
HTML

Najskuteczniejsze tagi dla plików PDF:

  • <h1> do <h6>: Tworzy jasną hierarchię dokumentów
  • : Doskonały dla danych strukturalnych i faktur
  • : Obsługuje osadzone obrazy i dane base64
  • z CSS: Precyzyjna kontrola układu

  • i : Standardowe formatowanie tekstu

    • i
        : Czyste formatowanie list

    Szczególne uwagi:

    Jak przetestować aplikację do generowania plików PDF?

    Po uruchomieniu projektu zobaczysz następujący ekran:

    Aplikacja okienkowa z polem tekstowym zawierającym kod HTML dla prostego pliku PDF i przycisk Konwertuj

    Wprowadź kod HTML w RichTextBox, na przykład:

    <h1>A Simple PDF File</h1><br><h6>Heading 6</h6>
    <h1>A Simple PDF File</h1><br><h6>Heading 6</h6>
    HTML

    Kliknij "Konwertuj". Pojawi się okno dialogowe zapisu pliku.

    Okno dialogowe zapisywania PDF w systemie Windows pokazujące przeglądarkę plików z wybranym dyskiem roboczym i nazwą pliku HtmlToPDF

    Po kliknięciu przycisku "Zapisz" plik zostanie zapisany w określonej ścieżce z podaną nazwą i lokalizacją.

    Które elementy HTML należy przetestować w pierwszej kolejności?

    Zacznij od tych przykładów HTML o rosnącym stopniu złożoności, aby zrozumieć możliwości renderowania IronPDF:

    Podstawowe formatowanie tekstu:

    <!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        .highlight { background-color: yellow; }
        .important { color: red; font-weight: bold; }
    </style>
</head>
<body>
    <h1>Test Document</h1>
    <p>This is <strong>bold</strong> and <em>italic</em> text.</p>
    <p class="highlight">Highlighted text example.</p>
    <p class="important">Important notice!</p>
</body>
</html>
    <!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        .highlight { background-color: yellow; }
        .important { color: red; font-weight: bold; }
    </style>
</head>
<body>
    <h1>Test Document</h1>
    <p>This is <strong>bold</strong> and <em>italic</em> text.</p>
    <p class="highlight">Highlighted text example.</p>
    <p class="important">Important notice!</p>
</body>
</html>
    HTML

    Tabela ze stylizacją:

    <table style="border-collapse: collapse; width: 100%;">
    <tr style="background-color: #f2f2f2;">
        <th style="border: 1px solid #ddd; padding: 8px;">Product</th>
        <th style="border: 1px solid #ddd; padding: 8px;">Price</th>
    </tr>
    <tr>
        <td style="border: 1px solid #ddd; padding: 8px;">IronPDF</td>
        <td style="border: 1px solid #ddd; padding: 8px;">$999</td>
    </tr>
</table>
    <table style="border-collapse: collapse; width: 100%;">
    <tr style="background-color: #f2f2f2;">
        <th style="border: 1px solid #ddd; padding: 8px;">Product</th>
        <th style="border: 1px solid #ddd; padding: 8px;">Price</th>
    </tr>
    <tr>
        <td style="border: 1px solid #ddd; padding: 8px;">IronPDF</td>
        <td style="border: 1px solid #ddd; padding: 8px;">$999</td>
    </tr>
</table>
    HTML

    Funkcje zaawansowane:

    
<img src="___PROTECTED_URL_118___" width="200" alt="Company Logo">

<div style="page-break-after: always;"></div>

<ul>
    <li>First item</li>
    <li>Second item</li>
</ul>
    
<img src="___PROTECTED_URL_118___" width="200" alt="Company Logo">

<div style="page-break-after: always;"></div>

<ul>
    <li>First item</li>
    <li>Second item</li>
</ul>
    HTML

    Przetestuj te elementy, aby upewnić się, że konwersja HTML do PDF działa zgodnie z oczekiwaniami.

    Jak mogę debugować, jeśli plik PDF nie jest generowany?

    W przypadku niepowodzenia generowania pliku PDF należy postępować zgodnie z poniższą systematyczną procedurą debugowania:

    1. Włącz rejestrowanie:

      IronPdf.Logging.Logger.EnableDebugging = true;
IronPdf.Logging.Logger.LogFilePath = "IronPdfLog.txt";
IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All;
      IronPdf.Logging.Logger.EnableDebugging = true;
IronPdf.Logging.Logger.LogFilePath = "IronPdfLog.txt";
IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All;
      IronPdf.Logging.Logger.EnableDebugging = True
IronPdf.Logging.Logger.LogFilePath = "IronPdfLog.txt"
IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All
      $vbLabelText   $csharpLabel

    2. Sprawdź poprawność kodu HTML:

      // Validate HTML before conversion
private bool IsValidHtml(string html)
{
try
{
    var doc = new HtmlAgilityPack.HtmlDocument();
    doc.LoadHtml(html);
    return doc.ParseErrors.Count() == 0;
}
catch
{
    return false;
}
}
      // Validate HTML before conversion
private bool IsValidHtml(string html)
{
try
{
    var doc = new HtmlAgilityPack.HtmlDocument();
    doc.LoadHtml(html);
    return doc.ParseErrors.Count() == 0;
}
catch
{
    return false;
}
}
      ' Validate HTML before conversion
Private Function IsValidHtml(html As String) As Boolean
    Try
        Dim doc As New HtmlAgilityPack.HtmlDocument()
        doc.LoadHtml(html)
        Return doc.ParseErrors.Count() = 0
    Catch
        Return False
    End Try
End Function
      $vbLabelText   $csharpLabel

    3. Use Chrome DevTools:

      • Zapisz kod HTML do pliku i otwórz go w przeglądarce Chrome
      • Naciśnij klawisz F12, aby sprawdzić, czy nie ma błędów JavaScript
      • Sprawdź konsolę pod kątem problemów
      • Użyj podglądu wydruku w przeglądarce Chrome, aby sprawdzić, jak będzie wyglądał wydruk

    4. Typowe problemy i rozwiązania:

    5. Przetestuj minimalny przykład: 
      // Start with the simplest possible HTML
var testHtml = "<h1>Test</h1>";
var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(testHtml);
pdf.SaveAs("test.pdf");
      // Start with the simplest possible HTML
var testHtml = "<h1>Test</h1>";
var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(testHtml);
pdf.SaveAs("test.pdf");
      ' Start with the simplest possible HTML
Dim testHtml = "<h1>Test</h1>"
Dim pdf = New ChromePdfRenderer().RenderHtmlAsPdf(testHtml)
pdf.SaveAs("test.pdf")
      $vbLabelText   $csharpLabel

    Jakie są typowe problemy podczas uruchamiania aplikacji?

    Oto najczęstsze problemy, z jakimi borykają się początkujący programiści, oraz ich rozwiązania:

    1. "IronPdf.Exceptions.IronPdfDeploymentException"

    2. Błędy "Odmowa dostępu"

      • Nie zapisuj w katalogach chronionych (C:\, Program Files)
      • Użycie Environment.SpecialFolder dla bezpiecznych ścieżek
      • Sprawdź uprawnienia IIS dla aplikacji internetowych

    3. Duże rozmiary plików

      • Zastosuj kompresję pliku PDF: 
        pdf.CompressImages(90); // 90% quality
        pdf.CompressImages(90); // 90% quality
        pdf.CompressImages(90) ' 90% quality
        $vbLabelText   $csharpLabel

    4. Niska wydajność

    5. Brakująca treść

    W przypadku utrzymujących się problemów należy zapoznać się z obszernym przewodnikiem dotyczącym rozwiązywania problemów.

    Jak wygląda ostateczny plik PDF?

    Wynikowy dokument PDF będzie wyglądał następująco:

    Zrzut ekranu prostego pliku PDF wyświetlający tytuł 'Prosty plik PDF' i tekst 'Nagłówek 6' na białym tle

    Jak mogę poprawić jakość pliku PDF?

    Popraw jakość swoich plików PDF dzięki tym profesjonalnym technikom:

    1. Renderowanie w wysokiej rozdzielczości:

      renderer.RenderingOptions.PrintHtmlBackgrounds = true;
renderer.RenderingOptions.ImageQuality = 95; // Higher quality for images
renderer.RenderingOptions.DPI = 300; // Print-quality resolution
      renderer.RenderingOptions.PrintHtmlBackgrounds = true;
renderer.RenderingOptions.ImageQuality = 95; // Higher quality for images
renderer.RenderingOptions.DPI = 300; // Print-quality resolution
      renderer.RenderingOptions.PrintHtmlBackgrounds = True
renderer.RenderingOptions.ImageQuality = 95 ' Higher quality for images
renderer.RenderingOptions.DPI = 300 ' Print-quality resolution
      $vbLabelText   $csharpLabel

    2. Profesjonalny styl:

      <style>
@page {
    size: A4;
    margin: 2cm;
}
body {
    font-family: 'Segoe UI', Tahoma, sans-serif;
    line-height: 1.6;
    color: #333;
}
h1 {
    color: #2c3e50;
    border-bottom: 2px solid #3498db;
    padding-bottom: 10px;
}
</style>
      <style>
@page {
    size: A4;
    margin: 2cm;
}
body {
    font-family: 'Segoe UI', Tahoma, sans-serif;
    line-height: 1.6;
    color: #333;
}
h1 {
    color: #2c3e50;
    border-bottom: 2px solid #3498db;
    padding-bottom: 10px;
}
</style>
      HTML

    3. Dodaj elementy wizualne:

    4. Optymalizacja pod kątem różnych zastosowań:

    Dlaczego wynik może wyglądać inaczej niż oczekiwano?

    Kilka czynników może powodować różnice w renderowaniu między podglądem HTML a plikiem PDF:

    1. Typy mediów CSS: Pliki PDF domyślnie wykorzystują media PRINT. Dodaj style specyficzne dla druku:

      @media print {
.no-print { display: none; }
body { font-size: 12pt; }
}

    2. Dostępność czcionek: Osadź czcionki niestandardowe, aby zapewnić spójność:

      @font-face {
font-family: 'MyFont';
src: url('data:font/woff2;base64,...') format('woff2');
}

    3. Treści dynamiczne: Treści renderowane przez JavaScript potrzebują czasu na załadowanie:

      renderer.RenderingOptions.RenderDelay = 2000; // Wait 2 seconds
      renderer.RenderingOptions.RenderDelay = 2000; // Wait 2 seconds
      renderer.RenderingOptions.RenderDelay = 2000 ' Wait 2 seconds
      $vbLabelText   $csharpLabel

    4. Różnice między przeglądarkami: IronPDF korzysta z silnika Chromium, dlatego w celu uzyskania dokładnego podglądu należy przeprowadzić testy w przeglądarce Chrome. Dowiedz się więcej o rendererze Chrome.

    5. Rozdzielczość i skalowanie: DPI monitora różni się od DPI PRINT. Użyj ustawień okna wyświetlania, aby zapewnić spójne renderowanie.

    Aby uzyskać renderowanie z dokładnością co do piksela, postępuj zgodnie z przewodnikiem najlepszych praktyk dotyczących konwersji HTML do PDF.

    Jakie są kolejne kroki po tym samouczku?

    Powyższy samouczek wyjaśnia, jak utworzyć plik PDF z HTML przy użyciu biblioteki IronPDF.

    Więcej informacji można znaleźć na oficjalnej stronie IronPDF. Biblioteka oferuje również inne funkcje, które umożliwiają pełną personalizację plików PDF, programowe łączenie i dzielenie plików lub po prostu przeglądanie przykładowych kodów ilustrujących różne funkcje.

    Możesz to sprawdzić, korzystając z klucza 30-dniowego okresu próbnego. Obecnie dostępna jest doskonała oferta, w ramach której można otrzymać pięć produktów Iron Software w cenie zaledwie dwóch. Więcej informacji na temat licencji można znaleźć w sekcji Informacje o licencjach IronPDF.

    Jakie zaawansowane funkcje powinienem opanować w następnej kolejności?

    Po opanowaniu podstaw konwersji HTML do PDF zapoznaj się z tymi zaawansowanymi funkcjami:

    1. Formularze PDF: Twórz formularze do wypełnienia w celu gromadzenia danych:

      // Create interactive form fields
pdf.Form.Fields.Add(new PdfTextField("name", "Enter your name", 100, 100));
      // Create interactive form fields
pdf.Form.Fields.Add(new PdfTextField("name", "Enter your name", 100, 100));
      ' Create interactive form fields
pdf.Form.Fields.Add(New PdfTextField("name", "Enter your name", 100, 100))
      $vbLabelText   $csharpLabel

    2. Podpisy cyfrowe: zwiększ bezpieczeństwo i autentyczność dokumentów

    3. PDF Manipulation:

    4. Zaawansowane renderowanie:

    5. Optymalizacja wydajności:
      • Asynchroniczne renderowanie dla aplikacji internetowych
      • Przetwarzanie wsadowe wielu dokumentów
      • Strumieniowanie oszczędzające pamięć

    Zacznij od funkcji najbardziej istotnych dla wymagań Twojego projektu.

    Jak przejść z wersji próbnej do produkcyjnej?

    Przejście z wersji próbnej do produkcyjnej obejmuje kilka ważnych kroków:

    1. Wybierz odpowiednią licencję:

      • Lite: Jeden programista, jeden projekt
      • Plus: Jeden programista, wiele projektów
      • Professional: Małe zespoły (do 3 programistów)
      • Nieograniczona: zespoły korporacyjne
    2. Zastosuj swój klucz licencyjny: 
      
// In application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
      
// In application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
      $vbLabelText   $csharpLabel

    // Or via configuration // appsettings.json (for .NET Core) { "IronPdf.License.LicenseKey": "YOUR-LICENSE-KEY" }

    

3. **Usuń znaki wodne wersji próbnej**: Wersje licencjonowane automatycznie usuwają znaki wodne wersji próbnej ze wszystkich wygenerowanych plików PDF.

4. **Kwestie związane z wydajnością**:
   - Testowanie na danych w skali produkcyjnej
   - Wdrożenie [odpowiedniej obsługi błędów](/troubleshooting/engineering-support-for-ironpdf/)
   - Skonfiguruj [rejestrowanie w celu monitorowania](/how-to/custom-logging/)

5. **Lista kontrolna wdrożenia**:
   - Sprawdź [wymagania serwera](/get-started/windows/)
   - Test na docelowej [platformie wdrożeniowej](/get-started/azure/)
   - Skonfiguruj [IIS, jeśli to konieczne](/troubleshooting/ironpdf-and-iis/)
   - Skonfiguruj [ciągłą integrację](/get-started/installation-overview/)

Szczegółowe wytyczne dotyczące licencji można znaleźć w sekcji [FAQ dotyczącej licencji](/licensing/).

### Gdzie mogę znaleźć bardziej złożone przykłady?

Poszerz swoją wiedzę o IronPDF dzięki tym obszernym zasobom:

1. **[Biblioteka przykładów kodu](/examples/)**:
   - [Generowanie faktur](/how-to/csharp-pdf-reports/)
   - [Tworzenie raportów](/how-to/csharp-pdf-reports/)
   - [Przetwarzanie wsadowe](/examples/parallel/)

2. **[Seria samouczków](/tutorials/)**:
   - [Kompletny przewodnik po konwersji HTML do PDF](/tutorials/html-to-pdf/)
   - [Tworzenie plików PDF od podstaw](/tutorials/csharp-create-pdf-complete-tutorial/)
   - [Zaawansowana edycja plików PDF](/tutorials/csharp-edit-pdf-complete-tutorial/)

3. **[Przewodniki integracji](/how-to/html-string-to-pdf/)**:
   - [Integracja z ASP.NET MVC](/how-to/cshtml-to-pdf-mvc-core/)
   - [Aplikacje Blazor](/how-to/blazor-tutorial/)
   - [Wdrożenie w Azure](/how-to/azure/)

4. **[Dokumentacja API](/object-reference/api/)**:
   - Kompleksowe opisy klas
   - Sygnatury metod i parametry
   - Fragmenty kodu dla każdej funkcji

5. **Zasoby społeczności**:
   - [Tag IronPDF na Stack Overflow](https://stackoverflow.com/questions/tagged/ironpdf)
   - [Przykłady z serwisu GitHub](https://github.com/iron-software)
   - Pomoc techniczna za pośrednictwem [centrum pomocy](/)

Zacznij od przykładów najbardziej zbliżonych do Twojego przypadku użycia i stopniowo odkrywaj bardziej zaawansowane funkcje w miarę potrzeb.

    Często Zadawane Pytania

    Jak mogę przekonwertować HTML na PDF w języku C#?

    Możesz użyć metody RenderHtmlAsPdf biblioteki IronPDF do konwersji ciągów HTML na pliki PDF. Wystarczy utworzyć obiekt HtmlToPdf i wywołać tę metodę, aby renderować kod HTML do dokumentu PDF.

    Jakie kroki należy wykonać, aby skonfigurować projekt Visual Studio do generowania plików PDF?

    Zacznij od otwarcia programu Visual Studio 2019, wybierz opcję „Utwórz nowy projekt”, wybierz „Aplikacja Windows Forms” i nadaj nazwę projektowi. Następnie zainstaluj IronPDF za pośrednictwem NuGet, aby rozpocząć integrację funkcji generowania plików PDF.

    Jak zainstalować bibliotekę do generowania plików PDF w Visual Studio?

    Możesz zainstalować IronPDF, przechodząc do konsoli menedżera pakietów w Visual Studio i wykonując polecenie: Install-Package IronPdf.

    Jakie elementy powinny znaleźć się w formularzu do generowania plików PDF?

    Należy uwzględnić etykietę z instrukcją, pole tekstowe Rich Text Box do wprowadzania kodu HTML oraz przycisk z napisem „Convert”, który użytkownicy będą klikać w celu wygenerowania pliku PDF.

    Jak zaimplementować kod zaplecza do tworzenia plików PDF?

    Użyj IronPDF do zadeklarowania obiektu HtmlToPdf. Pobierz dane wejściowe HTML z pola tekstowego, poproś użytkownika o zapisanie pliku PDF i wyrenderuj HTML za pomocą metody RenderHtmlAsPdf.

    Jaka jest funkcja obiektu HtmlToPdf w bibliotece PDF?

    Obiekt HtmlToPdf w IronPDF służy do przekształcania treści HTML w dokumenty PDF przy użyciu wszechstronnych funkcji konwersji biblioteki.

    Jak mogę sprawdzić, czy mój projekt generowania plików PDF działa poprawnie?

    Uruchom projekt w Visual Studio, wprowadź kod HTML do pola RichTextBox i kliknij „Convert”. Następnie użyj okna SaveFileDialog, aby wybrać lokalizację dla pliku PDF, upewniając się, że konwersja została pomyślnie zakończona.

    Jakie zaawansowane funkcje oferuje biblioteka PDF?

    IronPDF umożliwia tworzenie w pełni konfigurowalnych plików PDF, a także programowe łączenie i dzielenie plików. Biblioteka udostępnia również przykładowe kody dla różnych funkcji.

    Czy mogę wypróbować bibliotekę PDF przed zakupem?

    Tak, na oficjalnej stronie internetowej IronPDF dostępny jest 30-dniowy okres próbny, który pozwala zapoznać się z funkcjami programu przed podjęciem decyzji o zakupie.

    Gdzie mogę znaleźć szczegóły dotyczące licencji biblioteki PDF?

    Szczegółowe informacje na temat licencji IronPDF można znaleźć na stronie Informacje o licencjach IronPDF na ich stronie internetowej, w tym opcje i aktualne oferty.

    Czy IronPDF jest kompatybilny z .NET 10?

    Tak — IronPDF obsługuje już wszystkie nowoczesne wersje .NET i jest zgodny z nadchodzącą wersją .NET 10, której premiera zaplanowana jest na listopad 2025 r. Działa od razu z projektami .NET 10 bez konieczności stosowania dodatkowych rozwiązań. (ironpdf.com/blog/using-ironpdf/5-steps-to-generate-a-pdf-file-in-c-sharp/)

    Curtis Chau
    Curtis Chau
      Czat z zespołem inżynierów teraz
    Autor tekstów technicznych

    Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

    Czytaj więcej

    Powiązane artykuły

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

    Zespół wsparcia Iron

    Jesteśmy online 24 godziny, 5 dni w tygodniu.
    Czat
    E-mail
    Zadzwoń do mnie