Biblioteka PDF dla C#

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

Install-Package IronPdf

FILMY

Jak dodawać stemple i znaki wodne do plików PDF w języku C#

Curtis Chau

Updated: 19 lipca 2026

Migracja zPDFBoltdo IronPDF przenosi twój przebieg PDF .NET z usługi SaaS wyłącznie w chmurze na lokalnie hostowaną bibliotekę z lokalnym przetwarzaniem dokumentów i bez limitów na dokument. Ten przewodnik zapewnia szczegółową ścieżkę migracji, która eliminuje zależności sieciowe, ograniczenia miesięcznego użycia i zewnętrzną transmisję danych, jednocześnie dodając funkcje manipulacji PDF-ami, które nie są zapewnione przez PDFBolt.

Dlaczego warto przejść zPDFBoltna IronPDF

Problem związany wyłącznie z chmurą

PDFBolt jest platformą SaaS wyłącznie w chmurze ujawnioną jako REST API; nie istnieje oficjalne SDK .NET ani pakiet NuGet PDFBolt. Integracja jest wykonana ręcznie z HttpClient przeciwko https://api.pdfbolt.com/v1/direct. Chociaż wygodna dla szybkich prototypów, ta architektura stwarza wyzwania dla produkcyjnych aplikacji:

Przetwarzanie wyłącznie w chmurze: Każdy dokument przechodzi przez serweryPDFBolt— brak opcji hostowanej lokalnie, co może stanowić blokadę dla zespołów potrzebujących większej kontroli nad przepływem danych.
Uwagi dotyczące prywatności danych: Wrażliwe dokumenty (umowy, dane medyczne, dane finansowe) są przekazywane zewnętrznie. Firmy zajmujące się regulowanymi danymi będą miały uzasadnione obawy dotyczące przeglądu.
Limity użytkowania: Darmowy limit to 100 dokumentów miesięcznie, 20 żądań/minutę, 1 jednoczesne żądanie, co może nie wystarczać dla obciążeń produkcyjnych. Płatne poziomy (według pdfbolt.com/pricing) wahają się od 19 $/miesiąc do 249 $/miesiąc.
Zależność od sieci: Przestoje internetowe lub czas przestojuPDFBoltoznaczają, że twoje generowanie PDF całkowicie się zatrzymuje.
Opóźnienie: W porównaniu z przetwarzaniem lokalnym, przesył danych w obie strony w sieci wydłuża każdą konwersję o kilka sekund.
Przegląd zgodności: Audyty GDPR, HIPAA i SOC2 zazwyczaj wymagają dodatkowej dokumentacji, gdy przetwarzanie dokumentów odbywa się zewnętrznie.
Bezpieczeństwo kluczy API: Wyciek kluczy API może skutkować nieautoryzowanym wykorzystaniem, za które zostanie naliczona opłata na Twoim koncie.
Blokada dostawcy: Twoja aplikacja przestaje działać, jeśliPDFBoltzmienia warunki lub zamyka się.

PorównaniePDFBolti IronPDF

Zastrzeżenie	PDFBolt	IronPDF
Lokalizacja danych	Serwery zewnętrzne	Tylko Twoje serwery
Ograniczenia użytkowania	100 darmowych na miesiąc, następnie warstwowe subskrypcje	Nieograniczona
Wymagane połączenie z Internetem	Tak, zawsze	Nie
Opóźnienie	Ruch sieciowy w obie strony	Lokalny
Zgodność	Złożone (przetwarzanie zewnętrzne)	Proste (przetwarzanie lokalne)
Model kosztowy	Warstwy subskrypcji miesięcznej (19–249 $/miesiąc)	Jednorazowe lub roczne
Praca w trybie offline	Niemożliwe	W pełni obsługiwane
Kluczowe ryzyka związane z API	Wyciek = rozliczenie	Klucz licencyjny, brak ryzyka związanego z rozliczeniami

IronPDF zapewnia hostowaną lokalnie bazę we współczesnym .NET, która utrzymuje przetwarzanie dokumentów lokalnie i usuwa zależność od zewnętrznej usługi chmury.

Zanim zaczniesz

Wymagania wstępne

Środowisko .NET: .NET Framework 4.6.2+ lub .NET Core 3.1+ / .NET 5/6/7/8/9+
Dostęp do NuGet: Możliwość instalowania pakietów NuGet
Licencja IronPDF: Uzyskaj klucz licencyjny na stronie ironpdf.com

Zmiany w pakiecie NuGet

PDFBolt nie ma oficjalnego SDK .NET ani pakietu NuGet PDFBolt, więc nie ma nic do odinstalowania. Czyszczenie po stroniePDFBoltpolega na usunięciu ręcznie wykonanego wrappera HttpClient oraz żądań/odpowiedzi DTO. Następnie zainstaluj IronPDF:

# Install IronPDF(replaces the hand-rolled HttpClient wrapper)
dotnet add package IronPdf

# Install IronPDF(replaces the hand-rolled HttpClient wrapper)
dotnet add package IronPdf

SHELL

Konfiguracja licencji

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Zidentyfikuj zastosowanie PDFBolt

# Find allPDFBoltREST calls
grep -rE "api\.pdfbolt\.com|API-KEY|/v1/direct" --include="*.cs" .

# Find API key references
grep -r "PDFBOLT\|ApiKey" --include="*.cs" --include="*.json" --include="*.config" .

# Find allPDFBoltREST calls
grep -rE "api\.pdfbolt\.com|API-KEY|/v1/direct" --include="*.cs" .

# Find API key references
grep -r "PDFBOLT\|ApiKey" --include="*.cs" --include="*.json" --include="*.config" .

SHELL

Kompletna dokumentacija API

Mapowanie głównych koncepcji

PDFBolt (REST)	IronPDF
`HttpClient` + `API-KEY` nagłówek	`new ChromePdfRenderer()`
Ciało żądania JSON	`renderer.RenderingOptions`
`POST https://api.pdfbolt.com/v1/direct`	`renderer.RenderHtmlAsPdf(...)` / `RenderUrlAsPdf(...)`
Odpowiedź `byte[]`	`PdfDocument`

Mapowanie metod konwersji

PDFBolt (REST)	IronPDF
`POST /v1/direct` z `{ "html": <base64> }`	`renderer.RenderHtmlAsPdf(html)`
`POST /v1/direct` z `{ "url": "..." }`	`renderer.RenderUrlAsPdf(url)`

Mapowania metod wyjściowych

PDFBolt (REST)	IronPDF
`await response.Content.ReadAsByteArrayAsync()` następnie `File.WriteAllBytes`	`pdf.SaveAs(path)`
`await response.Content.ReadAsByteArrayAsync()`	`pdf.BinaryData`

Mapowania konfiguracji stron

PDFBolt JSON	IronPDF
`"format": "A4"`	`renderer.RenderingOptions.PaperSize = PdfPaperSize.A4`
`"margin": { "top": "20mm" }`	`renderer.RenderingOptions.MarginTop = 20`
`"margin": { "bottom": "20mm" }`	`renderer.RenderingOptions.MarginBottom = 20`
`"margin": { "left": "15mm" }`	`renderer.RenderingOptions.MarginLeft = 15`
`"margin": { "right": "15mm" }`	`renderer.RenderingOptions.MarginRight = 15`

Mapowanie symboli zastępczych nagłówków/stopek

PDFBolt (wewnątrz zakodowanej base64 `headerTemplate` / `footerTemplate`)	IronPDF (`HtmlFragment` token)
`<span class="pageNumber"></span>`	`{page}`
`<span class="totalPages"></span>`	`{total-pages}`
`<span class="date"></span>`	`{date}`
`<span class="title"></span>`	`{html-title}`

Przykłady migracji kodu

Przykład 1: Podstawowy HTML do PDF

Przed (PDFBolt — REST poprzez HttpClient):

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var payload = JsonSerializer.Serialize(new
        {
            html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
        });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
    }
}

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var payload = JsonSerializer.Serialize(new
        {
            html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
        });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
    }
}

Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim payload As String = JsonSerializer.Serialize(New With {
            .html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
        })

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim payload As String = JsonSerializer.Serialize(New With {
            .html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
        })

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Imports IronPdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Różnica strukturalna polega na modelu integracji.PDFBoltwymaga zakodowania HTML w base64, zbudowania ładunku JSON, ustawienia nagłówka API-KEY, POST do https://api.pdfbolt.com/v1/direct, oczekiwania na odpowiedź i samodzielnego zapisu zwróconych bajtów na dysku.

ChromePdfRenderer.RenderHtmlAsPdf()IronPDF zwraca obiekt PdfDocument z wbudowaną metodą SaveAs(). Model obiektowy pozwala manipulować PDF-em (dodawać znaki wodne, łączyć dokumenty, stosować zabezpieczenia) przed zapisaniem. Jeśli potrzebujesz surowych bajtów ze względu na zgodność z istniejącym kodem, użyj pdf.BinaryData. Dodatkowe opcje renderowania można znaleźć w dokumentacji dotyczącej konwersji HTML do PDF.

Przykład 2: Konwersja adresów URL do formatu PDF

Przed (PDFBolt — REST poprzez HttpClient):

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var payload = JsonSerializer.Serialize(new { url = "https://www.example.com" });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
    }
}

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var payload = JsonSerializer.Serialize(new { url = "https://www.example.com" });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
    }
}

Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim payload = JsonSerializer.Serialize(New With {.url = "https://www.example.com"})

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("webpage.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim payload = JsonSerializer.Serialize(New With {.url = "https://www.example.com"})

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("webpage.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

Po stroniePDFBoltkonwersja URL nadal wymaga pełnej podróży REST: zbudowanie ciało JSON, ustawienie nagłówka klucza API, oczekiwanie na POST i zapisanie bajtów odpowiedzi. Chociaż już wskazujesz na publiczny URL, zarówno pobranie, jak i renderowanie odbywa się na serwerach PDFBolt.

RenderUrlAsPdf()IronPDF zwraca PdfDocument z wbudowaną metodą SaveAs(). Kluczową zaletą jest to, że IronPDF wykonuje pobranie URL i renderowanie PDF lokalnie — żadne dane dokumentu nie opuszczają twojej infrastruktury. Dowiedz się więcej o konwersji adresów URL do formatu PDF.

Przykład 3: Plik HTML z niestandardowymi ustawieniami strony

Przed (PDFBolt — REST poprzez HttpClient):

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/parameters
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = await File.ReadAllTextAsync("input.html");
        var payload = JsonSerializer.Serialize(new
        {
            html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
            format = "A4",
            margin = new { top = "20mm", bottom = "20mm" },
            printBackground = true
        });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
    }
}

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/parameters
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = await File.ReadAllTextAsync("input.html");
        var payload = JsonSerializer.Serialize(new
        {
            html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
            format = "A4",
            margin = new { top = "20mm", bottom = "20mm" },
            printBackground = true
        });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
    }
}

Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html = Await File.ReadAllTextAsync("input.html")
        Dim payload = JsonSerializer.Serialize(New With {
            .html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
            .format = "A4",
            .margin = New With {.top = "20mm", .bottom = "20mm"},
            .printBackground = True
        })

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html = Await File.ReadAllTextAsync("input.html")
        Dim payload = JsonSerializer.Serialize(New With {
            .html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
            .format = "A4",
            .margin = New With {.top = "20mm", .bottom = "20mm"},
            .printBackground = True
        })

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        var html = File.ReadAllText("input.html");
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        var html = File.ReadAllText("input.html");
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Rendering
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        Dim html = File.ReadAllText("input.html")
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Imports IronPdf
Imports IronPdf.Rendering
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        Dim html = File.ReadAllText("input.html")
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Ten przykład pokazuje mapowanie konfiguracji strony.PDFBoltakceptuje główny obiekt format plus zagnieżdżony obiekt margin, którego wartości są ciągami stylów CSS ("20mm").IronPDF używa obiektu RenderingOptions na rendererze z właściwościami o silnie typowanej strukturze.

Kluczowe powiązania:

"format": "A4" → PdfPaperSize.A4 (silnie typowany enum)
"margin": { "top": "20mm" } → RenderingOptions.MarginTop = 20 (numeryczne mm)

Marginesy IronPDFsą zawsze numerycznymi milimetrami, więc ciągi jednostek CSSPDFBoltjak "20mm" mapują się bezpośrednio. Przestrzeń nazw IronPdf.Rendering jest wymagana do dostępu do enum PdfPaperSize. Dla dodatkowej konfiguracji strony zobacz dokumentację opcji renderowania.

Ważne uwagi dotyczące migracji

Zmiana typu zwracanej wartości

Endpoint /v1/directPDFBoltzwraca surowy PDF jako ciało odpowiedzi HTTP;IronPDF zwraca PdfDocument:

//PDFBoltpattern:
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("output.pdf", pdfBytes);

//IronPDF pattern:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Or if you need bytes:
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;

//PDFBoltpattern:
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("output.pdf", pdfBytes);

//IronPDF pattern:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Or if you need bytes:
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;

Zmiana modelu integracji

Kształt integracji zmienia się z klienta REST na bibliotekę wewnątrzprocesową:

// PDFBolt
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
// ... build JSON, POST to https://api.pdfbolt.com/v1/direct

// IronPDF
var renderer = new ChromePdfRenderer();

// PDFBolt
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
// ... build JSON, POST to https://api.pdfbolt.com/v1/direct

// IronPDF
var renderer = new ChromePdfRenderer();

Imports System.Net.Http

' PDFBolt
Using http As New HttpClient()
    http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
    ' ... build JSON, POST to https://api.pdfbolt.com/v1/direct
End Using

' IronPDF
Dim renderer As New ChromePdfRenderer()

Imports System.Net.Http

' PDFBolt
Using http As New HttpClient()
    http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
    ' ... build JSON, POST to https://api.pdfbolt.com/v1/direct
End Using

' IronPDF
Dim renderer As New ChromePdfRenderer()

Zmiana wzorca konfiguracji

KonfiguracjaPDFBoltto pola JSON w ciele żądania;IronPDF używa RenderingOptions:

// PDFBolt: JSON request fields
new { format = "A4", margin = new { top = "20mm" } }

// IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;

// PDFBolt: JSON request fields
new { format = "A4", margin = new { top = "20mm" } }

// IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;

' PDFBolt: JSON request fields
New With {Key .format = "A4", Key .margin = New With {Key .top = "20mm"}}

' IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20

' PDFBolt: JSON request fields
New With {Key .format = "A4", Key .margin = New With {Key .top = "20mm"}}

' IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20

Eliminacja klucza API

PDFBolt wymaga nagłówka API-KEY na każdym żądaniu;IronPDF używa jednorazowego klucza licencyjnego:

// PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config["PDFBolt:ApiKey"]);

// IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();

// PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config["PDFBolt:ApiKey"]);

// IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();

' PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config("PDFBolt:ApiKey"))

' IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim renderer As New ChromePdfRenderer()

' PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config("PDFBolt:ApiKey"))

' IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim renderer As New ChromePdfRenderer()

Usuń obsługę błędów sieciowych

Lokalne przetwarzanie oznacza brak błędów sieciowych do obsługi:

// PDFBolt: Network error handling required
catch (HttpRequestException ex)
catch (TaskCanceledException)
catch (TimeoutException)

// IronPDF: Remove network-specific catches entirely

// PDFBolt: Network error handling required
catch (HttpRequestException ex)
catch (TaskCanceledException)
catch (TimeoutException)

// IronPDF: Remove network-specific catches entirely

net

net

Nowe dostępne funkcje

Po migracji do IronPDF zyskujesz możliwości, których nie zapewnia PDFBolt:

// PDF Merging (not available in PDFBolt)
var merged = PdfDocument.Merge(pdf1, pdf2);

// Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>");

// Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret";

// Text Extraction (not available in PDFBolt)
string text = pdf.ExtractAllText();

// PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png");

// PDF Merging (not available in PDFBolt)
var merged = PdfDocument.Merge(pdf1, pdf2);

// Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>");

// Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret";

// Text Extraction (not available in PDFBolt)
string text = pdf.ExtractAllText();

// PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png");

' PDF Merging (not available in PDFBolt)
Dim merged = PdfDocument.Merge(pdf1, pdf2)

' Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>")

' Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret"

' Text Extraction (not available in PDFBolt)
Dim text As String = pdf.ExtractAllText()

' PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png")

' PDF Merging (not available in PDFBolt)
Dim merged = PdfDocument.Merge(pdf1, pdf2)

' Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>")

' Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret"

' Text Extraction (not available in PDFBolt)
Dim text As String = pdf.ExtractAllText()

' PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png")

Rozwiązywanie problemów

Problem 1: Brak pakietu `PDFBolt` na NuGet

Problem: Szukam using PDFBolt; / new HtmlToPdfConverter() w IronPDF.

**Rozwiązanie:**PDFBoltnie ma SDK .NET — jego integracja opiera się na HttpClient przeciwko https://api.pdfbolt.com/v1/direct.IronPDF całkowicie zastępuje ten wrapper przez ChromePdfRenderer:

// IronPDF
var renderer = new ChromePdfRenderer();

// IronPDF
var renderer = new ChromePdfRenderer();

' IronPDF
Dim renderer As New ChromePdfRenderer()

' IronPDF
Dim renderer As New ChromePdfRenderer()

Problematyczny 2: Gdzie zniknął `ConvertHtmlString`?

Problem: Migracja wewnętrznego wrappera PDFBolt, który ujawniał metodę ConvertHtmlString(html).

Rozwiązanie: Skorzystaj z RenderHtmlAsPdf():

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);

net

net

Problematyczny 3: Gdzie zniknął `ConvertUrl`?

Problem: Migracja wewnętrznego wrappera PDFBolt, który ujawniał metodę ConvertUrl(url).

Rozwiązanie: Skorzystaj z RenderUrlAsPdf():

// IronPDF
var pdf = renderer.RenderUrlAsPdf(url);

// IronPDF
var pdf = renderer.RenderUrlAsPdf(url);

net

net

Problem 4: Pola JSON `format` → Enum

Problem: Tłumaczenie pola JSON "format": "A4" z PDFBolt.

Rozwiązanie: Skorzystaj z PdfPaperSize z IronPdf.Rendering:

// IronPDF
using IronPdf.Rendering;
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

// IronPDF
using IronPdf.Rendering;
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

Imports IronPdf.Rendering

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

Imports IronPdf.Rendering

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

Problem 5: Powolne generowanie pierwszego pliku PDF

Problem: Wstępne renderowanie trwa dłużej niż oczekiwano.

Rozwiązanie: Silnik Chromium inicjuje się przy pierwszym użyciu. W razie potrzeby przygotuj się wcześniej:

// Warm up during application startup
var renderer = new ChromePdfRenderer();
renderer.RenderHtmlAsPdf("<html><body></body></html>");

// Warm up during application startup
var renderer = new ChromePdfRenderer();
renderer.RenderHtmlAsPdf("<html><body></body></html>");

' Warm up during application startup
Dim renderer As New ChromePdfRenderer()
renderer.RenderHtmlAsPdf("<html><body></body></html>")

' Warm up during application startup
Dim renderer As New ChromePdfRenderer()
renderer.RenderHtmlAsPdf("<html><body></body></html>")

Lista kontrolna migracji

Przed migracją

Inwentaryzuj wszystkie wywołania RESTPDFBoltw kodowej bazie (api.pdfbolt.com)
Udokumentuj bieżące pola żądań JSON (format, margin, printBackground, headerTemplate, itd.)
Zidentyfikuj kod zarządzania kluczem API w celu usunięcia
Lista obsługi ponownych prób po limitach 429/quota do usunięcia
Uzyskaj klucz licencyjny IronPDF

Zmiany w pakiecie

Usuń ręcznie wykonany wrapperPDFBoltHttpClient i DTO (brak pakietu NuGet do odinstalowania)
Zainstaluj pakiet NuGet IronPdf: dotnet add package IronPdf
Dodaj przestrzeń nazw using IronPdf;
Dodaj using IronPdf.Rendering; dla enumów rozmiarów papieru

Zmiany w kodzie

Dodaj konfigurację klucza licencyjnego podczas uruchamiania
Zastąp integrację HttpClient + API-KEY przez ChromePdfRenderer
Zastąp POST /v1/direct przez RenderHtmlAsPdf() / RenderUrlAsPdf()
Zastąp await response.Content.ReadAsByteArrayAsync() + File.WriteAllBytes() przez pdf.SaveAs() (lub pdf.BinaryData jeśli nadal potrzebne są bajty)
Zmapuj pola JSON "format" / "margin" na RenderingOptions.PaperSize / RenderingOptions.MarginTop itd.
Usuń kod zarządzania kluczem API
Usuń obsługę limitów 429 / wskaźników użycia
Usuń obsługę błędów sieciowych

Po migracji

Usuń klucz API z plików konfiguracyjnych
Usuń klucz API z menedżerów sekretów
Uruchom wszystkie testy porównujące wynik w formacie PDF
Sprawdź, czy rozmiary stron i marginesy wyświetlają się poprawnie
Rozważ dodanie nowych funkcji (znaki wodne, zabezpieczenia, scałanie)

Zwróć uwagę: PDFBolt to zastrzeżony znak towarowy swojego właściciela. Ta strona nie jest powiązana, popierana ani sponsorowana przez PDFBolt. Wszystkie nazwy produktów, logo i marki są własnością ich odpowiednich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.

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ęczników.

...

Czytaj więcej