PORóWNANIE

PDFBolt vs IronPDF: Przewodnik po porównaniu technicznym

Zaktualizowano:

Kiedy programiści .NET muszą tworzyć dokumenty PDF, stają przed kluczową decyzją: skorzystać z usług w chmurze, takich jak PDFBolt, czy wybrać biblioteki hostowane samodzielnie, takie jak IronPDF. W niniejszej analizie przeanalizowano obie opcje pod kątem ważnych aspektów technicznych, aby pomóc programistom, architektom i decydentom w wyborze odpowiedniego narzędzia do generowania plików PDF.

Czym jest PDFBolt?

PDFBolt jest opartą na chmurze usługą REST API do generowania PDFów za pomocą zewnętrznych serwerów. Deweloperzy wysyłają treść HTML lub adresy URL za pomocą żądań HTTP POST do punktów końcowych API PDFBolt, które przetwarzają treść za pomocą bezgłowego przeglądarki Chromium i zwracają wygenerowane PDFy.

Oparte na chmurze rozwiązanie oferuje szybką integrację — deweloperzy uzyskują klucz API i wykonują żądania HTTP za pomocą standardowego klienta HTTP dowolnego języka (np. HttpClient w C#, requests w Python, fetch w Node.js).PDFBoltzarządza infrastrukturą renderowania, eliminując potrzebę korzystania z lokalnych zasobów do generowania plików PDF.

Jednak ta wygoda wiąże się z pewnymi kompromisami. Każdy dokument przechodzi przez serweryPDFBoltz siedzibą w UE (Niemcy). Bezpłatna wersja ograniczona do 100 dokumentów miesięcznie, z dostępnymi płatnymi planami subskrypcyjnymi na większe wolumeny. Ponadto połączenie sieciowe jest obowiązkowe dla wszystkich operacji generowania plików PDF.

Czym jest IronPDF?

IronPDF to biblioteka .NET do samodzielnego hostowania, która generuje pliki PDF lokalnie na serwerach użytkownika. Klasa ChromePdfRenderer wykorzystuje wbudowany silnik Chromium do konwersji HTML, CSS i JavaScript na wysokiej jakości dokumenty PDF bez żadnych zewnętrznych wywołań sieciowych.

Biblioteka przetwarza wszystkie dokumenty w ramach infrastruktury aplikacji. Żadne dane nie opuszczają serwerów, a generowanie dokumentów nie podlega żadnym ograniczeniom. Po uzyskaniu licencji można generować nieograniczoną liczbę plików PDF bez ponoszenia kosztów za każdy dokument.

IronPDF oferuje zarówno metody synchroniczne, jak i asynchroniczne, a także szerokie możliwości wykraczające poza podstawowe generowanie — w tym scałanie plików PDF, dodawanie znaków wodnych, wyodrębnianie tekstu oraz ustawienia zabezpieczeń, których interfejsy API w chmurze zazwyczaj nie są w stanie zapewnić.

Porównanie architektury

Główna różnica międzyPDFBoltaIronPDFpolega na tym, gdzie odbywa się przetwarzanie dokumentów. To rozróżnienie ma wpływ na wszystko, od prywatności danych po niezawodność operacyjną.

Funkcja PDFBolt IronPDF
Hosting Wyłącznie w chmurze (serwery w UE) Własny hosting
Lokalizacja danych Zewnętrzne serwery (Niemcy) Tylko Twoje serwery
Prywatność Dokumenty przetwarzane zewnętrznie Pełna prywatność danych — lokalne przetwarzanie, brak przekazywania osobom trzecim
Ograniczenia użytkowania Oparte na kwotach (100-50 000/miesiąc w zależności od planu) Nieograniczona
Wymagane połączenie z Internetem Tak, zawsze Nie
Opóźnienie Uwzględnia podróż w obie strony sieci Przetwarzanie lokalne
Praca w trybie offline Niemożliwe W pełni obsługiwane
Integracja z C# REST API przez HttpClient Bezpośrednia integracja bibliotek
Model kosztowy Miesięczna subskrypcja z ilością dokumentów Zakup jednorazowy lub subskrypcja

Dla aplikacji obsługujących wrażliwe dokumenty — umowy, dokumentacja medyczna, dane finansowe — istotne jest, gdzie dane opuszczają Twoją infrastrukturę.IronPDFprzetwarza wszystko lokalnie, więc żadna zawartość dokumentu nie jest przesyłana na zewnątrz. To upraszcza zgodność z GDPR, HIPAA i SOC2, ponieważ nie występuje żaden zewnętrzny procesor danych i nie ma transferu danych do audytu.

Podstawowa konwersja HTML do PDF

Oba narzędzia obsługują konwersję HTML do PDF, choć z zasadniczo różnymi podejściami —PDFBoltprzez wywołania REST API, aIronPDFprzez bibliotekę C#.

PodejściePDFBoltdo konwersji HTML na PDF:

// REST API: requires an API key from pdfbolt.com
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");

        var html = "<html><body><h1>Hello World</h1></body></html>";
        var base64Html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html));

        var response = await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            new { html = base64Html });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
// REST API: requires an API key from pdfbolt.com
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");

        var html = "<html><body><h1>Hello World</h1></body></html>";
        var base64Html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html));

        var response = await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            new { html = base64Html });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
Imports System
Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.IO
Imports System.Text
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim client As New HttpClient()
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY")

        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim base64Html As String = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))

        Dim response = Await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            New With {.html = base64Html})
        Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
        File.WriteAllBytes("output.pdf", pdfBytes)
    End Function
End Module
$vbLabelText   $csharpLabel

PodejścieIronPDFdo konwersji HTML na 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");
    }
}
// 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
$vbLabelText   $csharpLabel

Bezpośredni punkt końcowy APIPDFBoltzwraca surowe dane binarne PDF w formacie odpowiedzi HTTP, które można zapisać z File.WriteAllBytes().IronPDFRenderHtmlAsPdf() zwraca obiekt PdfDocument z wygodnymi metodami, takimi jak SaveAs(), oraz właściwościami, takimi jak BinaryData i Stream, do alternatywnego przetwarzania wyników.

Proces konwersji HTML do PDF wIronPDFodbywa się całkowicie lokalnie, bez sieciowych transferów, które zwiększają opóźnienie każdej konwersji.

Konwersja adresów URL do formatu PDF

Konwersja stron internetowych do formatu PDF przebiega według podobnych schematów, z istotnymi różnicami w nazewnictwie metod i przetwarzaniu.

PodejściePDFBolt"URL-to-PDF":

// REST API: requires an API key from pdfbolt.com
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");

        var response = await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            new { url = "https://www.example.com" });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}
// REST API: requires an API key from pdfbolt.com
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");

        var response = await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            new { url = "https://www.example.com" });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}
Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim client As New HttpClient()
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY")

        Dim response = Await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            New With {.url = "https://www.example.com"})
        Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
        File.WriteAllBytes("webpage.pdf", pdfBytes)
    End Function
End Module
$vbLabelText   $csharpLabel

PodejścieIronPDF"URL-to-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");
    }
}
// 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
$vbLabelText   $csharpLabel

IronPDF udostępnia dedykowaną metodę RenderUrlAsPdf, która jasno wskazuje wykonywaną operację. Powstały obiekt PdfDocument oferuje ten sam bogaty interfejs do zapisywania, uzyskiwania dostępu do danych binarnych lub dalszej manipulacji.

Niestandardowy rozmiar strony i marginesy

Profesjonalne dokumenty często wymagają określonych wymiarów stron i konfiguracji marginesów. Oba narzędzia obsługują te personalizacje z różnymi wzorcami konfiguracji.

Konfiguracja strony PDFBolt:

// REST API: requires an API key from pdfbolt.com
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");

        var html = File.ReadAllText("input.html");
        var base64Html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html));

        var response = await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            new
            {
                html = base64Html,
                format = "A4",
                margin = new { top = "20mm", bottom = "20mm" }
            });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
// REST API: requires an API key from pdfbolt.com
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");

        var html = File.ReadAllText("input.html");
        var base64Html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html));

        var response = await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            new
            {
                html = base64Html,
                format = "A4",
                margin = new { top = "20mm", bottom = "20mm" }
            });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
Imports System
Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.IO
Imports System.Text
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim client As New HttpClient()
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY")

        Dim html As String = File.ReadAllText("input.html")
        Dim base64Html As String = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))

        Dim response As HttpResponseMessage = Await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            New With {
                .html = base64Html,
                .format = "A4",
                .margin = New With {.top = "20mm", .bottom = "20mm"}
            })
        Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
        File.WriteAllBytes("output.pdf", pdfBytes)
    End Function
End Module
$vbLabelText   $csharpLabel

Konfiguracja strony 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
$vbLabelText   $csharpLabel

PDFBolt przyjmuje konfigurację jako parametry JSON w ciele żądania API (format, margin).IronPDFcentralizuje wszystkie konfiguracje za pomocą właściwości RenderingOptions, dzięki czemu ustawienia są wykrywalne przez autouzupełnianie w środowisku IDE.

PDFBolt obsługuje marginesy w wielu jednostkach (px, in, cm, mm), podczas gdyIronPDFwyraża marginesy w milimetrach. Oba obsługują standardowe rozmiary papieru —PDFBoltza pomocą parametru ciągu format (np. "A4"), aIronPDFza pomocą wyliczenia PdfPaperSize.

Przewodnik po mapowaniu API

Dla zespołów rozważających przejście zPDFBoltna IronPDF, zrozumienie mapowania API pomaga oszacować wysiłek. Zauważ, żePDFBoltkorzysta z parametrów REST API (pola JSON), podczas gdyIronPDFkorzysta z klas i metod C#.

Mapowania podstawowych operacji

PDFBolt(REST API) IronPDF(biblioteka C#)
POST /v1/direct z {"html": "<base64>"} renderer.RenderHtmlAsPdf(html)
POST /v1/direct z {"url": "... renderer.RenderUrlAsPdf(url)
Treść odpowiedzi (surowe bajty PDF) pdf.SaveAs(path)
"isEncoded": true (odpowiedź Base64) pdf.BinaryData

Mapowania parametrów konfiguracji

PDFBolt(parametr JSON) IronPDF(właściwość C#)
"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

Mapowania dynamicznej zawartości nagłówków/stopki

Oba narzędzia obsługują nagłówki i stopki oparte na HTML z dynamiczną zawartością, używając różnych składni:

PDFBolt(klasa CSS w HTML) IronPDF(symbol zastępczy) Cel
<span class="pageNumber"></span> {page} Numer bieżącej strony
<span class="totalPages"></span> {total-pages} Łączna liczba stron
<span class="date"></span> {date} Aktualna data
<span class="title"></span> {html-title} Tytuł dokumentu
<span class="url"></span> {url} URL strony

Zarówno PDFBolt, jak iIronPDFobsługują nagłówki i stopki oparte na HTML z stylizacją CSS. ParametryPDFBoltheaderTemplate i footerTemplate akceptują kodowane w Base64 HTML, podczas gdyIronPDFużywa ciągów HTML bezpośrednio w swoich opcjach renderingowych.

Porównanie dostępności funkcji

Oprócz podstawowej konwersji HTML do PDF, narzędzia różnią się znacząco pod względem dostępnych możliwości.

Funkcja PDFBolt IronPDF
HTML do PDF ✓ ✓
URL do pliku PDF ✓ ✓
Nagłówki/stopki ✓(HTML) ✓(HTML)
Numery stron ✓ ✓
Niestandardowe rozmiary stron ✓ ✓
Marginesy ✓ ✓
Łączenie plików PDF ✗ ✓
Dzielenie plików PDF ✗ ✓
Znaki wodne ✗ ✓
Ochrona hasłem ✗ ✓
Ekstrakcja tekstu ✗ ✓
PDF na obrazy ✗ ✓
Wypełnianie formularzy ✗ ✓
Podpisy cyfrowe ✗ ✓
Praca w trybie offline ✗ ✓
Nieograniczona wydajność Oparte na kwotach (do 50 000/miesiąc) Nieograniczona

IronPDF zapewnia szerokie możliwości manipulacji plikami PDF, w tym scałanie, dzielenie, dodawanie znaków wodnych oraz ustawienia zabezpieczeń, których interfejsy API w chmurze zazwyczaj nie są w stanie zaoferować ze względu na bezstanowy charakter żądań API.

Ochrona danych i zgodność z przepisami

Różnice architektoniczne powodują zasadniczo odmienne cechy przetwarzania danych:

Przepływ danych w PDFBolt:

  1. Twoja aplikacja wysyła HTML/URL do serwerówPDFBoltz siedzibą w UE (Niemcy) 2.PDFBoltprzetwarza dokument, korzystając z infrastruktury chmurkowej
  2. Generowane pliki PDF zwracane przez sieć
  3. Treść dokumentu jest przesyłana i przetwarzana na zewnętrznych serwerach

Przepływ danych w IronPDF:

  1. Twoja aplikacja przetwarza HTML/URL lokalnie
  2. Silnik Chromium renderuje plik PDF w trakcie przetwarzania
  3. Dane w formacie PDF nigdy nie opuszczają serwerów
  4. Brak udziału zewnętrznego procesora danych — brak potrzeby negocjacji DPA

Z IronPDF, dokumenty zawierające dane osobowe, chronione informacje zdrowotne lub poufne dane biznesowe nigdy nie opuszczają Twojej infrastruktury. Biblioteka zawiera również wbudowane funkcje zabezpieczeń wspierające przepływy zgodności: ochrona hasłem i szyfrowanie (do 256-bit AES), podpisy cyfrowe z certyfikatami PFX/P12 i obsługą HSM, ukrywanie tekstu dla stałego usuwania danych osobowych i zgodność z PDF/A dla długoterminowych wymagań archiwalnych. Dla zamkniętych środowiskIronPDFdziała bez potrzeby połączenia z Internetem.

Kiedy zespoły rozważają przejście zPDFBoltna IronPDF

Kilka czynników skłania zespoły do rozważeniaIronPDFjako alternatywy dla PDFBolt:

Wymagania dotyczące prywatności danych: Organizacje podlegające GDPR, HIPAA lub wewnętrznym politykom zarządzania danymi mogą wymagać, aby dokumenty nigdy nie opuszczały ich infrastruktury. Model lokalnego przetwarzaniaIronPDFzaspokaja to wymaganie z założenia — dane nie są przesyłane na zewnątrz, a wbudowane funkcje szyfrowania i ukrywania wspierają przepływy zgodności bezpośrednio.

Przyrost zużycia woluminów: Bezpłatna wersjaPDFBoltjest ograniczona do 100 dokumentów miesięcznie (żądania powyżej tego limitu są blokowane, a nie rozliczane). Płatne plany wahają się od 19 USD/miesiąc (2 000 dokumentów) do 249 USD/miesiąc (50 000 dokumentów) z możliwością przekroczenia limitu przy płatnych planach.IronPDFnie ma limitów dokumentów ani naliczania — po wykupieniu licencji generowanie jest nielimitowane.

Kwestie związane z niezawodnością sieci: Interfejsy API w chmurze wymagają połączenia sieciowego do każdej operacji. Aplikacje wdrażane w środowiskach o przerywanej łączności lub wymagające wysokiej dostępności korzystają z lokalnego przetwarzania, które działa niezależnie od stanu sieci.

Wrażliwość na opóźnienia: Każda konwersjaPDFBoltzawiera czas podróży sieciowej w obie strony oprócz czasu renderowania.IronPDFprzetwarza dokumenty lokalnie, całkowicie unikając obciążeń sieciowych.

Wymagania dotyczące funkcji: Gdy aplikacje wymagają łączenia plików PDF, dodawania znaków wodnych, wyodrębniania tekstu lub ustawień zabezpieczeń, interfejsy API w chmurze często nie są w stanie zapewnić tych możliwości. Kompleksowy zestaw funkcjiIronPDFzaspokaja te potrzeby bez konieczności korzystania z dodatkowych usług.

Zarządzanie kluczami API: Klucze API w chmurze wymagają bezpiecznego przechowywania i rotacji, ponieważ dają dostęp do płatnej usługi. Model klucza licencyjnegoIronPDFautentykuje lokalnie bez implikacji rozliczenia za użycie.

Porównanie instalacji

Ustawienia PDFBolt: PDFBolt nie wymaga instalacji pakietów — to API REST. Deweloperzy rejestrują się na pdfbolt.com, uzyskują klucz API i wykonują żądania HTTP za pomocą standardowego klienta HTTP w ich języku:

var client = new HttpClient();
client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");
var client = new HttpClient();
client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");
Dim client As New HttpClient()
client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY")
$vbLabelText   $csharpLabel

Instalacja IronPDF:

Install-Package IronPdf
Install-Package IronPdf
SHELL

IronPDF wymaga konfiguracji klucza licencyjnego podczas uruchamiania aplikacji:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

PDFBolt to niezależna od języka API REST, dostępna z dowolnej platformy (C#, Node.js, Python, Java, Go, PHP, Rust i więcej).IronPDFto biblioteka .NET wspierająca .NET Framework i nowoczesne wersje .NET, kompatybilna z aplikacjami celującymi w .NET 10 i C# 14.

Kwestie związane z trybem asynchronicznym i synchronicznym

Architektura opartego na chmurzePDFBoltkorzysta z asynchronicznych wzorców HTTP dla operacji sieciowych.PDFBoltoferuje trzy typy punktów końcowych: bezpośrednie (synchronizacja odpowiedzi binarnej), synchronizacja (synchronizacja JSON z adresem URL do pobrania) i asynchroniczne (na bazie webhooków):

//PDFBoltREST API pattern - async HTTP call
var client = new HttpClient();
client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");
var response = await client.PostAsJsonAsync(
    "https://api.pdfbolt.com/v1/direct",
    new { html = base64Html });
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
//PDFBoltREST API pattern - async HTTP call
var client = new HttpClient();
client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");
var response = await client.PostAsJsonAsync(
    "https://api.pdfbolt.com/v1/direct",
    new { html = base64Html });
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Threading.Tasks

'PDFBoltREST API pattern - async HTTP call
Dim client As New HttpClient()
client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY")
Dim response As HttpResponseMessage = Await client.PostAsJsonAsync(
    "https://api.pdfbolt.com/v1/direct",
    New With {.html = base64Html})
Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
$vbLabelText   $csharpLabel

IronPDF domyślnie udostępnia metody synchroniczne, ponieważ przetwarzanie lokalne nie wymaga asynchroniczności:

//IronPDFlocal pattern - sync by default
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
//IronPDFlocal pattern - sync by default
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
'IronPDFlocal pattern - sync by default
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
$vbLabelText   $csharpLabel

W przypadku aplikacji, które korzystają z wzorców asynchronicznych,IronPDFudostępnia również wersje metod asynchronicznych:

//IronPDFasync option
var pdf = await renderer.RenderHtmlAsPdfAsync(html);
//IronPDFasync option
var pdf = await renderer.RenderHtmlAsPdfAsync(html);
$vbLabelText   $csharpLabel

Charakterystyka wydajności

Lokalne kontra chmurowe przetwarzanie tworzy różne profile wydajności:

Metryka PDFBolt IronPDF
Przetwarzanie Renderowanie w chmurze + transfer sieciowy Renderowanie lokalne
Zależność od sieci Każde żądanie wymaga połączenia Brak
Przetwarzanie wsadowe Ograniczenia szybkości (20-150 żądań/min w zależności od planu) Brak limitów stawek
Jednoczesne żądania 1-20 w zależności od planu Ograniczone zasobami serwera
Praca w trybie offline Niemożliwe W pełni obsługiwane

Wbudowany wIronPDFsilnik Chromium ma narzut inicjalizacji przy pierwszym użyciu, ale kolejne renderowania unikają obciążeń sieciowych związanych z wywołaniami API chmury. WydajnośćPDFBoltzależy od warunków sieciowych, złożoności dokumentu i bieżącego obciążenia serwera.

Podejmowanie decyzji

Wybór międzyPDFBoltaIronPDFzależy od konkretnych wymagań:

RozważPDFBoltjeśli: Potrzebujesz szybkiej integracji dla prototypu, twoje wolumeny dokumentów pasują do poziomów subskrypcji PDFBolt, czujesz się komfortowo z chmurowym przetwarzaniem dokumentów, a połączenie sieciowe jest niezawodne.

Rozważ IronPDF, jeśli: potrzebujesz lokalnego przetwarzania danych ze względu na prywatność lub zgodność z przepisami, generujesz ponad 100 dokumentów miesięcznie, potrzebujesz funkcji manipulacji plikami PDF wykraczających poza generowanie (łączenie, znak wodny, zabezpieczenia), potrzebujesz możliwości pracy w trybie offline lub opóźnienia mają znaczenie dla komfortu użytkowania.

Dla zespołów tworzących aplikacje produkcyjne w 2025 r. i planujących działania na 2026 r. architekturaIronPDFoparta na własnym hostingu zapewnia niezależność operacyjną i wszechstronne możliwości, których nie są w stanie zapewnić interfejsy API w chmurze.

Pierwsze kroki z IronPDF

Aby ocenićIronPDFpod kątem swoich potrzeb w zakresie generowania plików PDF:

  1. Zainstaluj pakiet NuGet IronPDF: Install-Package IronPdf
  2. Zapoznaj się z samouczkiem dotyczącym konwersji HTML do PDF, aby poznać podstawowe wzorce konwersji
  3. Poznaj konwersję adresów URL do formatu PDF w celu przechwytywania stron internetowych
  4. Zapoznaj się z sekcją samouczków, aby uzyskać wyczerpujące przykłady

Dokumentacja IronPDF zawiera szczegółowe wskazówki dotyczące typowych scenariuszy, a Dokumentacja API opisuje wszystkie dostępne klasy i metody.