Przy tworzeniu nowoczesnych aplikacji .NET, które wymagają funkcji PDF, wybór odpowiedniej biblioteki może znacznie wpłynąć na szybkość rozwoju, wydajność aplikacji i koszty utrzymania w długim okresie. IronPDF i EvoPdf reprezentują dwa różne podejścia do generowania i manipulacji PDF w ekosystemie .NET, z unikalnymi mocnymi stronami, które odpowiadają różnym scenariuszom rozwoju.
To kompleksowe porównanie bada obie biblioteki w kluczowych wymiarach, w tym dokładność renderowania, projektowanie API, wskaźniki wydajności, kompatybilność platform i całkowite koszty posiadania. Niezależnie od tego, czy tworzysz system przetwarzania dokumentów o dużej wydajności, implementujesz podpisy cyfrowe dla zgodności, czy po prostu konwertujesz raporty HTML na PDF, zrozumienie tych różnic pomoże podjąć świadomą decyzję, która będzie zgodna z Twoimi wymaganiami technicznymi i ograniczeniami budżetowymi.
Przed zanurzeniem się w szczegółowej analizie, oto przegląd tego, jak te biblioteki wypadają w kluczowych kategoriach, które są najważniejsze dla deweloperów .NET:
| Kategoria | Funkcja/Aspekt | IronPDF | EvoPdf | Kluczowa zaleta |
|---|---|---|---|---|
| Podstawowa architektura | Filozofia projektowania | Prostota przede wszystkim, intuicyjne API | Funkcje bogate, tradycyjne podejście do PDF | IronPDF: Szybsze tworzenie |
| Złożoność API | Proste metody jak RenderHtmlAsPdf() | Podejście wieloklasowe z większą ilością ustawień | IronPDF: Prostsza powierzchnia API | |
| Krzywa uczenia się | Minimalna wymagana konfiguracja | Zaangażowana większa konfiguracja | IronPDF: Szybsze przyswajanie | |
| Obsługa platform | Wielopłatformowe | Natwne wsparcie, bez dodatkowej konfiguracji | Wymagana konfiguracja specyficzna dla platformy | IronPDF: Łatwiejsze wdrożenie |
| Wersje .NET | .NET 10, 9, 8, 7, 6, 5, Core 3.1+, Framework 4.6.2+ | .NET 10, 9, 8, 7, 6, Standard 2.0+, Framework 4.0+ | Oba: Wsparcie nowoczesnego frameworka | |
| Systemy operacyjne | Windows, Linux, macOS, Docker natywnie | Windows, Linux, macOS, Azure | IronPDF: zoptymalizowane dla Dockera | |
| HTML do PDF | Silnik renderujący | Pełny silnik Chrome V8 | Niestandardowy silnik renderujący HTML | IronPDF: Wysoka wierność przeglądarki |
| Obsługa CSS3/HTML5 | Pełne wsparcie | Dobre wsparcie dla standardowych funkcji | IronPDF: Nowoczesne standardy internetowe | |
| Wykonanie JavaScript | Pełna obsługa JavaScript z oczekiwaniem | Dobre wsparcie JavaScript | IronPDF: Gotowość na dynamiczną treść | |
| Szybkość renderowania | Zoptymalizowane dla skomplikowanych stron z JavaScript | Szybkie dla prostego statycznego HTML | Zależy od złożoności dokumentu | |
| Security & Encryption | Poziomy szyfrowania | AES-256, niestandardowe procedury obsługi | Standard AES-256 | Oba: Standard branżowy |
| Opcje uprawnień | Szczegółowe kontrolki uprawnień | Podstawowy zestaw uprawnień | IronPDF: Precyzyjniejsza kontrola | |
| Podpisy cyfrowe | Zintegrowane, wizualne podpisy | Podstawowe wsparcie podpisu | IronPDF: Łatwiejsze podpisywanie | |
| Manipulacja treścią | Metoda redakcji | Prawdziwe usuwanie treści, jednowierszowe API | Brak wbudowanej rewizji | IronPDF: Gotowość do zapewnienia zgodności |
| Znak wodny | Oparty na HTML/CSS, pełna stylizacja | Watermarki na bazie szablonów | IronPDF: Bogate znaki wodne | |
| Stemplowanie | Ujednolicone klasy stempli | Takie samo jak funkcja watermarking | IronPDF: Dedykowane narzędzia | |
| Konwersja plików | DOCX do PDF | Wbudowany DocxToPdfRenderer | Requires Evo Word to PDF ($450+) | IronPDF: Bez dodatkowych kosztów |
| Doświadczenie programisty | Przykłady kodu | Ponad 100 gotowych do uruchomienia przykładów | Dostępne przykłady kodu | IronPDF: Rozległe zasoby |
| Dokumentacja | Samouczki, instrukcje, filmy, dokumentacja API | Dokumentacja API i przykłady | IronPDF: Wiele ścieżek nauki | |
| Komunikaty błędów | Opisowe, działające | Standardowe raportowanie błędów | IronPDF: Lepsze debugowanie | |
| Wskaźniki wydajności | Przetwarzanie dużych dokumentów | Przetwarzanie wsadowe o dużej przepustowości | Standardowe przetwarzanie wsadowe | IronPDF: Lepsza skalowalność |
| Obsługa wątków | Zoptymalizowane pod kątem natywnego async/await | Wsparcie dla wielowątkowości | IronPDF: Lepsza skalowalność | |
| Licensing & Pricing | Poziom początkowy | Lite: $999 (1 deweloper, 1 projekt) | Wdrożenie: $450 (1 serwer, 1 aplikacja) | EvoPdf: Niższy początkowy koszt |
| Licencja Team | Plus: $1,499 (3 deweloperów, 3 projekty) | Firma: $1,200 (nielimitowani deweloperzy) | EvoPdf: Lepsze dla dużych zespołów | |
| Redystrybucja | +$1,999 bez opłat licencyjnych | Zawarte w Company License | EvoPdf: Wbudowana redystrybucja | |
| Opcja Suite | Iron Suite: $2,998 (10 products) | Toolkit EVO PDF: $1,400 | IronPDF: Więcej produktów w zestawie | |
| Wsparcie | Wsparcie techniczne w cenie | Tak, wsparcie inżynierskie 24/5 | Tak, standardowe wsparcie techniczne w pierwszym roku | IronPDF: Bezpośredni dostęp dla inżynierów |
| Najlepsze dla | Przykłady zastosowań | Nowoczesne aplikacje internetowe, złożone pliki PDF, zgodność z przepisami | Proste konwersje z HTML do PDF, podstawowe konwersje | Zależy od kontekstu |
Uwaga. EvoPdf oferuje konkurencyjne ceny dla dużych zespołów. IronPDF zapewnia bardziej wszechstronne funkcje, w tym wbudowaną redakcję i wsparcie konwersji dokumentów.
IronPDF to kompleksowe rozwiązanie do obsługi plików PDF, zaprojektowane z myślą o wydajności programistów. Oparty na prostocie, ale nie tracący przy tym na mocy, IronPDF pozwala programistom .NET tworzyć, edytować i modyfikować dokumenty PDF za pomocą intuicyjnych interfejsów API, które odzwierciedlają znane wzorce tworzenia stron internetowych. Wyróżniającą cechą biblioteki jest silnik renderujący oparty na przeglądarce Chrome, który zapewnia konwersję HTML do PDF z idealną dokładnością pikselową, jednocześnie obsługując najnowsze standardy internetowe, w tym CSS3, frameworki JavaScript i czcionki internetowe.
Biblioteka sprawdza się doskonale w sytuacjach wymagających wiernego renderowania dokumentów, złożonej obróbki plików PDF oraz funkcji bezpieczeństwa na poziomie Enterprise. Jego bogaty zestaw funkcji obejmuje nie tylko podstawowe generowanie plików PDF, ale także zaawansowane możliwości, takie jak podpisy cyfrowe, wypełnianie formularzy, integracja OCR poprzez IronOCR oraz płynna konwersja formatów dokumentów. Kompatybilność międzyplatformowa IronPDF wykracza poza zwykłą obsługę frameworków, oferując natywną wydajność w systemach Windows, Linux, macOS, kontenerach Docker oraz platformach chmurowych, takich jak Azure i AWS.
EvoPdf stosuje bardziej tradycyjne podejście do obróbki plików PDF, skupiając się przede wszystkim na konwersji HTML do PDF, kładąc nacisk na dostosowywanie i kontrolę. Biblioteka zapewnia programistom szczegółową kontrolę nad procesem konwersji, umożliwiając precyzyjne dostosowanie parametrów renderowania, układów stron i ustawień konwersji. Architektura EvoPdf została zbudowana w oparciu o zapewnienie niezawodnych, spójnych wyników w standardowych scenariuszach konwersji stron internetowych do formatu PDF.
EvoPdf wyróżnia się przede wszystkim niewielkim obciążeniem systemu i większą szybkością renderowania prostych dokumentów HTML. Dla prostych stron HTML bez złożonych funkcji JavaScript lub CSS3, EvoPdf jest dobrze przystosowany do przetwarzania wsadowego prostych dokumentów o dużych nakładach. Biblioteka oferuje również dobre wsparcie dla renderowania po stronie serwera w środowiskach ASP.NET, z optymalizacjami dla scenariuszy aplikacji internetowych.
IronPDF zapewnia płynną kompatybilność między platformami, wykraczającą poza zwykłą obsługę frameworków. Biblioteka działa natywnie na platformach:
Obsługa wersji .NET:
Kompatybilność z systemami operacyjnymi: Windows (x86, x64, ARM)
Integracja z platformą chmurową:
To, co wyróżnia IronPDF, to model wdrażania bez konieczności konfiguracji. W przeciwieństwie do wielu bibliotek PDF, które wymagają dodatkowych zależności lub instalacji podczas działania, IronPDF zawiera swoje niezbędne komponenty w pakiecie NuGet. To samodzielne podejście znacznie zmniejsza złożoność wdrożenia i eliminuje typowe problemy typu "działa na moim komputerze".
EvoPdf obsługuje podobny zakres wersji .NET, ale wymaga bardziej starannej konfiguracji w scenariuszach wielopłatformowych:
Obsługa platformy .NET Framework:
Uwagi dotyczące platformy:
W przypadku wdrożeń wielopłatformowych użytkownicy EvoPdf często muszą radzić sobie z zależnościami i konfiguracjami specyficznymi dla danej platformy, szczególnie podczas przechodzenia między środowiskami Windows i Linux. Ta dodatkowa złożoność konfiguracji może wpłynąć na harmonogramy rozwoju i zwiększyć nakłady związane z utrzymaniem.
Najważniejszą funkcją obu bibliotek jest konwersja HTML do PDF, ale ich podejścia i wyniki znacznie się różnią.
using IronPdf;
// Initialize the Chrome-based renderer with advanced options
var renderer = new ChromePdfRenderer
{
// Configure rendering options for optimal quality
RenderingOptions = new ChromePdfRenderOptions
{
// Set high-quality rendering at 300 DPI for print-ready PDFs
DPI = 300,
// Enable JavaScript execution with custom timeout
EnableJavaScript = true,
RenderDelay = 2000, // Wait 2 seconds for dynamic content
// Configure page layout
MarginTop = 20,
MarginBottom = 20,
MarginLeft = 15,
MarginRight = 15,
// Enable modern web features
CssMediaType = PdfCssMediaType.Print,
ViewPortWidth = 1920,
// Optimize for web fonts and images
CreatePdfFormsFromHtml = true,
FitToPaperMode = FitToPaperModes.Automatic
}
};
// Convert complex HTML with CSS3 and JavaScript
var htmlContent = @"
<!DOCTYPE html>
<html>
<head>
<link href='https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;700&display=swap' rel='stylesheet'>
<style>
body { font-family: 'Roboto', sans-serif; }
.chart-container { width: 100%; height: 400px; }
@media print {
.no-print { display: none; }
.page-break { page-break-after: always; }
}
</style>
<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
</head>
<body>
<h1>Dynamic Sales Report</h1>
<div class='chart-container'>
<canvas id='salesChart'></canvas>
</div>
<script>
// Dynamic chart generation
const ctx = document.getElementById('salesChart').getContext('2d');
new Chart(ctx, {
type: 'line',
data: {
labels: ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
datasets: [{
label: 'Sales 2025',
data: [65, 78, 90, 81, 96],
borderColor: 'rgb(75, 192, 192)',
tension: 0.4
}]
}
});
</script>
</body>
</html>";
// Generate PDF with full JavaScript chart rendering
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Apply post-processing optimizations
pdf.CompressImages(90);
pdf.SaveAs("sales-report.pdf");Imports IronPdf
' Initialize the Chrome-based renderer with advanced options
Dim renderer As New ChromePdfRenderer With {
' Configure rendering options for optimal quality
.RenderingOptions = New ChromePdfRenderOptions With {
' Set high-quality rendering at 300 DPI for print-ready PDFs
.DPI = 300,
' Enable JavaScript execution with custom timeout
.EnableJavaScript = True,
.RenderDelay = 2000, ' Wait 2 seconds for dynamic content
' Configure page layout
.MarginTop = 20,
.MarginBottom = 20,
.MarginLeft = 15,
.MarginRight = 15,
' Enable modern web features
.CssMediaType = PdfCssMediaType.Print,
.ViewPortWidth = 1920,
' Optimize for web fonts and images
.CreatePdfFormsFromHtml = True,
.FitToPaperMode = FitToPaperModes.Automatic
}
}
' Convert complex HTML with CSS3 and JavaScript
Dim htmlContent As String = "
<!DOCTYPE html>
<html>
<head>
<link href='https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;700&display=swap' rel='stylesheet'>
<style>
body { font-family: 'Roboto', sans-serif; }
.chart-container { width: 100%; height: 400px; }
@media print {
.no-print { display: none; }
.page-break { page-break-after: always; }
}
</style>
<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
</head>
<body>
<h1>Dynamic Sales Report</h1>
<div class='chart-container'>
<canvas id='salesChart'></canvas>
</div>
<script>
// Dynamic chart generation
const ctx = document.getElementById('salesChart').getContext('2d');
new Chart(ctx, {
type: 'line',
data: {
labels: ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
datasets: [{
label: 'Sales 2025',
data: [65, 78, 90, 81, 96],
borderColor: 'rgb(75, 192, 192)',
tension: 0.4
}]
}
});
</script>
</body>
</html>"
' Generate PDF with full JavaScript chart rendering
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
' Apply post-processing optimizations
pdf.CompressImages(90)
pdf.SaveAs("sales-report.pdf")Ten przykład IronPDF pokazuje kilka zaawansowanych funkcji:
using EvoPdf;
// Create converter with configuration
HtmlToPdfConverter converter = new HtmlToPdfConverter();
// Set license key (required for production use)
converter.LicenseKey = "your-license-key";
// Configure conversion settings
converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
converter.PdfDocumentOptions.PdfPageOrientation = PdfPageOrientation.Portrait;
converter.PdfDocumentOptions.TopMargin = 20;
converter.PdfDocumentOptions.BottomMargin = 20;
converter.PdfDocumentOptions.LeftMargin = 15;
converter.PdfDocumentOptions.RightMargin = 15;
// Enable JavaScript execution
converter.JavaScriptEnabled = true;
converter.ConversionDelay = 2; // seconds
// Set authentication if needed
converter.AuthenticationOptions.Username = "username";
converter.AuthenticationOptions.Password = "password";
// Convert HTML string
string htmlString = @"
<html>
<head>
<style>
body { font-family: Arial, sans-serif; }
table { border-collapse: collapse; width: 100%; }
th, td { border: 1px solid #ddd; padding: 8px; }
</style>
</head>
<body>
<h1>Invoice</h1>
<table>
<tr>
<th>Item</th>
<th>Quantity</th>
<th>Price</th>
</tr>
<tr>
<td>Product A</td>
<td>5</td>
<td>$50.00</td>
</tr>
</table>
</body>
</html>";
// Perform conversion
byte[] pdfBytes = converter.ConvertHtml(htmlString, "");
// Save to file
System.IO.File.WriteAllBytes("invoice.pdf", pdfBytes);Imports EvoPdf
' Create converter with configuration
Private converter As New HtmlToPdfConverter()
' Set license key (required for production use)
converter.LicenseKey = "your-license-key"
' Configure conversion settings
converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4
converter.PdfDocumentOptions.PdfPageOrientation = PdfPageOrientation.Portrait
converter.PdfDocumentOptions.TopMargin = 20
converter.PdfDocumentOptions.BottomMargin = 20
converter.PdfDocumentOptions.LeftMargin = 15
converter.PdfDocumentOptions.RightMargin = 15
' Enable JavaScript execution
converter.JavaScriptEnabled = True
converter.ConversionDelay = 2 ' seconds
' Set authentication if needed
converter.AuthenticationOptions.Username = "username"
converter.AuthenticationOptions.Password = "password"
' Convert HTML string
Dim htmlString As String = "
<html>
<head>
<style>
body { font-family: Arial, sans-serif; }
table { border-collapse: collapse; width: 100%; }
th, td { border: 1px solid #ddd; padding: 8px; }
</style>
</head>
<body>
<h1>Invoice</h1>
<table>
<tr>
<th>Item</th>
<th>Quantity</th>
<th>Price</th>
</tr>
<tr>
<td>Product A</td>
<td>5</td>
<td>$50.00</td>
</tr>
</table>
</body>
</html>"
' Perform conversion
Dim pdfBytes() As Byte = converter.ConvertHtml(htmlString, "")
' Save to file
System.IO.File.WriteAllBytes("invoice.pdf", pdfBytes)Podejście EvoPdf koncentruje się na prostej konwersji HTML z dobrym wsparciem dla podstawowych stylów i układu. Chociaż dobrze radzi sobie ze standardowym HTML i CSS, może mieć trudności z nowoczesnymi funkcjami internetowymi, takimi jak CSS Grid, animacje Flexbox lub złożone frameworki JavaScript.
W przypadku dokumentów wrażliwych bezpieczeństwo ma ogromne znaczenie. Obie biblioteki oferują funkcje szyfrowania, ale o różnym stopniu zaawansowania.
using IronPdf;
using IronPdf.Security;
// Load an existing PDF or create new one
var pdf = PdfDocument.FromFile("confidential-report.pdf");
// Configure comprehensive security settings
pdf.SecuritySettings = new SecuritySettings
{
// Set owner password (full permissions)
OwnerPassword = "admin-complex-password-2025",
// Set user password (restricted permissions)
UserPassword = "user-password-readonly",
// Configure granular permissions
AllowAccessibilityExtractContent = false,
AllowAnnotations = false,
AllowAssembleDocument = false,
AllowCopy = false,
AllowFillForms = true,
AllowFullQualityPrint = false,
AllowModifyDocument = false,
AllowPrint = true,
// Use strongest encryption available
EncryptionLevel = EncryptionLevel.AES256Bit
};
// Add metadata security
pdf.MetaData.Author = "Authorized Personnel Only";
pdf.MetaData.ModifiedDate = DateTime.UtcNow;
pdf.MetaData.Title = "Confidential: Internal Use Only";
// Apply digital signature for authenticity
var signature = new PdfSignature("certificate.pfx", "cert-password")
{
SigningReason = "Document Approval",
SigningLocation = "Corporate Headquarters",
SigningContact = "security@company.com",
// Visual signature appearance
IsVisible = true,
X = 100,
Y = 100,
Width = 200,
Height = 50,
PageIndex = 0,
// Custom appearance
SignatureImage = new PdfSignatureImage("signature.png"),
DateFormat = "yyyy-MM-dd HH:mm:ss"
};
pdf.Sign(signature);
// Add watermark for additional security
pdf.ApplyWatermark("<h2 style='color:red; opacity:0.5;'>CONFIDENTIAL</h2>",
45, VerticalAlignment.Middle, HorizontalAlignment.Center);
pdf.SaveAs("secured-document.pdf");Imports IronPdf
Imports IronPdf.Security
' Load an existing PDF or create new one
Dim pdf = PdfDocument.FromFile("confidential-report.pdf")
' Configure comprehensive security settings
pdf.SecuritySettings = New SecuritySettings With {
.OwnerPassword = "admin-complex-password-2025",
.UserPassword = "user-password-readonly",
.AllowAccessibilityExtractContent = False,
.AllowAnnotations = False,
.AllowAssembleDocument = False,
.AllowCopy = False,
.AllowFillForms = True,
.AllowFullQualityPrint = False,
.AllowModifyDocument = False,
.AllowPrint = True,
.EncryptionLevel = EncryptionLevel.AES256Bit
}
' Add metadata security
pdf.MetaData.Author = "Authorized Personnel Only"
pdf.MetaData.ModifiedDate = DateTime.UtcNow
pdf.MetaData.Title = "Confidential: Internal Use Only"
' Apply digital signature for authenticity
Dim signature = New PdfSignature("certificate.pfx", "cert-password") With {
.SigningReason = "Document Approval",
.SigningLocation = "Corporate Headquarters",
.SigningContact = "security@company.com",
.IsVisible = True,
.X = 100,
.Y = 100,
.Width = 200,
.Height = 50,
.PageIndex = 0,
.SignatureImage = New PdfSignatureImage("signature.png"),
.DateFormat = "yyyy-MM-dd HH:mm:ss"
}
pdf.Sign(signature)
' Add watermark for additional security
pdf.ApplyWatermark("<h2 style='color:red; opacity:0.5;'>CONFIDENTIAL</h2>",
45, VerticalAlignment.Middle, HorizontalAlignment.Center)
pdf.SaveAs("secured-document.pdf")Implementacja zabezpieczeń IronPDF zapewnia funkcje klasy korporacyjnej:
using EvoPdf;
// Create security manager
PdfSecurityOptions securityOptions = new PdfSecurityOptions();
// Set basic security parameters
securityOptions.UserPassword = "user123";
securityOptions.OwnerPassword = "owner456";
securityOptions.KeySize = EncryptionKeySize.Key256Bit;
// Configure permissions
securityOptions.CanPrint = true;
securityOptions.CanCopyContent = false;
securityOptions.CanEditContent = false;
securityOptions.CanEditAnnotations = false;
securityOptions.CanFillFormFields = true;
securityOptions.CanAssembleDocument = false;
// Apply security to existing PDF
PdfSecurityManager securityManager = new PdfSecurityManager(securityOptions);
securityManager.SaveSecuredPdfToFile("input.pdf", "secured-output.pdf");Imports EvoPdf
' Create security manager
Private securityOptions As New PdfSecurityOptions()
' Set basic security parameters
securityOptions.UserPassword = "user123"
securityOptions.OwnerPassword = "owner456"
securityOptions.KeySize = EncryptionKeySize.Key256Bit
' Configure permissions
securityOptions.CanPrint = True
securityOptions.CanCopyContent = False
securityOptions.CanEditContent = False
securityOptions.CanEditAnnotations = False
securityOptions.CanFillFormFields = True
securityOptions.CanAssembleDocument = False
' Apply security to existing PDF
Dim securityManager As New PdfSecurityManager(securityOptions)
securityManager.SaveSecuredPdfToFile("input.pdf", "secured-output.pdf")EvoPdf zapewnia podstawowe funkcje bezpieczeństwa odpowiednie do podstawowej ochrony dokumentów, choć brakuje mu niektórych zaawansowanych opcji dostępnych w IronPDF.
W dzisiejszym środowisku, w którym dużą wagę przywiązuje się do prywatności, możliwość trwałego usuwania poufnych informacji z plików PDF ma kluczowe znaczenie dla zgodności z przepisami takimi jak RODO, HIPAA i CCPA.
using IronPdf;
// Load PDF containing sensitive information
PdfDocument pdf = PdfDocument.FromFile("customer-records.pdf");
// Redact using multiple strategies
// 1. Redact specific text patterns (SSN format)
pdf.RedactTextOnAllPages(@"\b\d{3}-\d{2}-\d{4}\b",
isRegex: true,
new RedactionOptions
{
RedactionColor = Color.Black,
RedactionStyle = RedactionStyle.Filled,
DrawRedactionBorder = true,
BorderColor = Color.Red
});
// 2. Redact specific phrases
pdf.RedactTextOnPages("Confidential",
new[] { 0, 1, 2 }, // Specific pages
caseSensitive: false);
// 3. Redact regions by coordinates
pdf.RedactRegion(new Rectangle(100, 200, 300, 50), 0);
// 4. Use advanced pattern matching for credit cards
string creditCardPattern = @"\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13})\b";
pdf.RedactTextOnAllPages(creditCardPattern, isRegex: true);
// Apply OCR-based redaction for scanned documents
pdf.ApplyOcr(new TesseractLanguage[] { TesseractLanguage.English });
pdf.RedactTextOnAllPages("Salary:");
// Save with audit trail
pdf.MetaData.CustomProperties.Add("Redacted", DateTime.UtcNow.ToString());
pdf.MetaData.CustomProperties.Add("RedactedBy", Environment.UserName);
pdf.SaveAs("redacted-records.pdf");Imports IronPdf
' Load PDF containing sensitive information
Private pdf As PdfDocument = PdfDocument.FromFile("customer-records.pdf")
' Redact using multiple strategies
' 1. Redact specific text patterns (SSN format)
pdf.RedactTextOnAllPages("\b\d{3}-\d{2}-\d{4}\b", isRegex:= True, New RedactionOptions With {
.RedactionColor = Color.Black,
.RedactionStyle = RedactionStyle.Filled,
.DrawRedactionBorder = True,
.BorderColor = Color.Red
})
' 2. Redact specific phrases
pdf.RedactTextOnPages("Confidential", { 0, 1, 2 }, caseSensitive:= False)
' 3. Redact regions by coordinates
pdf.RedactRegion(New Rectangle(100, 200, 300, 50), 0)
' 4. Use advanced pattern matching for credit cards
Dim creditCardPattern As String = "\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13})\b"
pdf.RedactTextOnAllPages(creditCardPattern, isRegex:= True)
' Apply OCR-based redaction for scanned documents
pdf.ApplyOcr(New TesseractLanguage() { TesseractLanguage.English })
pdf.RedactTextOnAllPages("Salary:")
' Save with audit trail
pdf.MetaData.CustomProperties.Add("Redacted", DateTime.UtcNow.ToString())
pdf.MetaData.CustomProperties.Add("RedactedBy", Environment.UserName)
pdf.SaveAs("redacted-records.pdf")Funkcje redagowania w IronPDF obejmują:
IronPDF zawiera wbudowaną funkcję zaciemniania, co czyni go dobrym wyborem dla aplikacji wymagających zgodności z przepisami o ochronie prywatności, takimi jak GDPR, HIPAA i CCPA.
Obie biblioteki obsługują formularze PDF, ale mają różne podejścia do ich tworzenia i edycji.
using IronPdf;
using IronPdf.Forms;
// Create a new PDF with an HTML form
var html = @"
<html>
<body>
<h2>Employee Information Form</h2>
<form>
<label>Full Name:</label>
<input type='text' name='fullName' required />
<label>Email:</label>
<input type='email' name='email' required />
<label>Department:</label>
<select name='department'>
<option value=''>Select Department</option>
<option value='IT'>Information Technology</option>
<option value='HR'>Human Resources</option>
<option value='Sales'>Sales</option>
</select>
<label>Start Date:</label>
<input type='date' name='startDate' />
<label>
<input type='checkbox' name='agreement' />
I agree to the terms and conditions
</label>
<button type='submit'>Submit</button>
</form>
</body>
</html>";
var renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
CreatePdfFormsFromHtml = true // Enable form field creation
}
};
var pdf = renderer.RenderHtmlAsPdf(html);
// Programmatically fill form fields
pdf.Form.SetFieldValue("fullName", "John Doe");
pdf.Form.SetFieldValue("email", "john.doe@company.com");
pdf.Form.SetFieldValue("department", "IT");
pdf.Form.SetFieldValue("startDate", DateTime.Now.ToString("yyyy-MM-dd"));
pdf.Form.SetCheckBoxValue("agreement", true);
// Make specific fields read-only
pdf.Form.Fields["email"].ReadOnly = true;
// Add form field validation
foreach (var field in pdf.Form.Fields)
{
if (field.Name == "email")
{
field.Annotation.BorderColor = Color.Blue;
field.Annotation.BackgroundColor = Color.LightGray;
}
}
// Flatten form (convert to static content)
var flattenedPdf = pdf.Flatten();
flattenedPdf.SaveAs("completed-form.pdf");
// Or save as fillable form
pdf.SaveAs("fillable-form.pdf");Imports IronPdf
Imports IronPdf.Forms
' Create a new PDF with an HTML form
Dim html = "
<html>
<body>
<h2>Employee Information Form</h2>
<form>
<label>Full Name:</label>
<input type='text' name='fullName' required />
<label>Email:</label>
<input type='email' name='email' required />
<label>Department:</label>
<select name='department'>
<option value=''>Select Department</option>
<option value='IT'>Information Technology</option>
<option value='HR'>Human Resources</option>
<option value='Sales'>Sales</option>
</select>
<label>Start Date:</label>
<input type='date' name='startDate' />
<label>
<input type='checkbox' name='agreement' />
I agree to the terms and conditions
</label>
<button type='submit'>Submit</button>
</form>
</body>
</html>"
Dim renderer = New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.CreatePdfFormsFromHtml = True ' Enable form field creation
}
}
Dim pdf = renderer.RenderHtmlAsPdf(html)
' Programmatically fill form fields
pdf.Form.SetFieldValue("fullName", "John Doe")
pdf.Form.SetFieldValue("email", "john.doe@company.com")
pdf.Form.SetFieldValue("department", "IT")
pdf.Form.SetFieldValue("startDate", DateTime.Now.ToString("yyyy-MM-dd"))
pdf.Form.SetCheckBoxValue("agreement", True)
' Make specific fields read-only
pdf.Form.Fields("email").ReadOnly = True
' Add form field validation
For Each field In pdf.Form.Fields
If field.Name = "email" Then
field.Annotation.BorderColor = Color.Blue
field.Annotation.BackgroundColor = Color.LightGray
End If
Next
' Flatten form (convert to static content)
Dim flattenedPdf = pdf.Flatten()
flattenedPdf.SaveAs("completed-form.pdf")
' Or save as fillable form
pdf.SaveAs("fillable-form.pdf")Funkcje obsługi formularzy w IronPDF:
Charakterystyka wydajności różni się znacznie w zależności od złożoności dokumentu i przypadku użycia:
// Performance comparison for batch processing
public class PerformanceBenchmark
{
public static async Task RunBenchmark()
{
var htmlTemplates = GenerateInvoiceTemplates(1000);
var stopwatch = new Stopwatch();
// IronPDF batch processing with optimization
Console.WriteLine("IronPDF Batch Processing:");
stopwatch.Start();
var renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
RenderDelay = 0, // No delay for static content
EnableJavaScript = false, // Disable JS for speed
DPI = 150 // Lower DPI for faster rendering
}
};
// Parallel processing
var tasks = htmlTemplates.Select(async (html, index) =>
{
var pdf = await renderer.RenderHtmlAsPdfAsync(html);
await pdf.SaveAsAsync($"ironpdf-invoice-{index}.pdf");
});
await Task.WhenAll(tasks);
stopwatch.Stop();
Console.WriteLine($"Time: {stopwatch.ElapsedMilliseconds}ms");
Console.WriteLine($"Average: {stopwatch.ElapsedMilliseconds / 1000.0}ms per PDF");
// Memory usage
var process = Process.GetCurrentProcess();
Console.WriteLine($"Memory: {process.WorkingSet64 / 1024 / 1024}MB");
}
}' Performance comparison for batch processing
Public Class PerformanceBenchmark
Public Shared Async Function RunBenchmark() As Task
Dim htmlTemplates = GenerateInvoiceTemplates(1000)
Dim stopwatch = New Stopwatch()
' IronPDF batch processing with optimization
Console.WriteLine("IronPDF Batch Processing:")
stopwatch.Start()
Dim renderer = New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.RenderDelay = 0, ' No delay for static content
.EnableJavaScript = False, ' Disable JS for speed
.DPI = 150 ' Lower DPI for faster rendering
}
}
' Parallel processing
Dim tasks = htmlTemplates.Select(Function(html, index) Async Function()
Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)
Await pdf.SaveAsAsync($"ironpdf-invoice-{index}.pdf")
End Function)
Await Task.WhenAll(tasks)
stopwatch.Stop()
Console.WriteLine($"Time: {stopwatch.ElapsedMilliseconds}ms")
Console.WriteLine($"Average: {stopwatch.ElapsedMilliseconds / 1000.0}ms per PDF")
' Memory usage
Dim process = Process.GetCurrentProcess()
Console.WriteLine($"Memory: {process.WorkingSet64 / 1024 / 1024}MB")
End Function
End ClassRozważania wydajnościowe według scenariusza:
IronPDF oferuje różne opcje cenowe, w tym licencje Lite, Plus i Professional, z opcją redystrybucji bez opłat licencyjnych. Model licencjonowania jest zaprojektowany tak, aby skalować się z potrzebami zespołu i projektu (ceny na kwiecień 2026):
Lite License: $999
Plus License: $1,499
Professional License: $2,399
Dodatkowe Opcje:
EVO PDF Toolkit oraz samodzielny konwerter HTML na PDF oferują dwa poziomy licencji — Deployment i Company (ceny na kwiecień 2026; sprawdź aktualne ceny na evopdf.com/buy.aspx):
Licencja Deployment:
Licencja Company:
Przeanalizujmy scenariusze z rzeczywistego świata, aby zrozumieć rzeczywiste implikacje kosztowe:
Często niedocenianym czynnikiem przy wyborze biblioteki PDF jest wsparcie dla nowoczesnych frameworków CSS. Zdominowanie web developingu przez Bootstrap, Tailwind CSS i Foundation, zdolność twojej biblioteki do obsługi tych frameworków bezpośrednio wpływa na efektywność produkcji i jakość wyników.
Pełny silnik Chrome V8 w IronPDF zapewnia natywne wsparcie dla wszystkich nowoczesnych frameworków CSS bez kompromisów:
Przykład Kodu: Komponent Oś czasu Bootstrap
using IronPdf;
var renderer = new ChromePdfRenderer();
string bootstrapTimeline = @"
<!DOCTYPE html>
<html>
<head>
<link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
<style>
.timeline { position: relative; padding: 20px 0; }
.timeline::before {
content: '';
position: absolute;
left: 50%;
width: 2px;
height: 100%;
background: #dee2e6;
}
.timeline-item { position: relative; margin: 20px 0; }
</style>
</head>
<body>
<div class='container py-5'>
<h2 class='text-center mb-5'>Project Timeline</h2>
<div class='timeline'>
<div class='timeline-item'>
<div class='row'>
<div class='col-md-6'>
<div class='card shadow-sm'>
<div class='card-body'>
<h5 class='card-title'>Phase 1: Planning</h5>
<p class='text-muted'>Q1 2025</p>
<p class='card-text'>Initial project scope and requirements gathering completed.</p>
<span class='badge bg-success'>Completed</span>
</div>
</div>
</div>
</div>
</div>
<!-- Additional timeline items... -->
</div>
</div>
</body>
</html>";
var pdf = renderer.RenderHtmlAsPdf(bootstrapTimeline);
pdf.SaveAs("project-timeline.pdf");Niestandardowy silnik renderowania HTML w EvoPdf zapewnia solidne wsparcie CSS z pewnymi ograniczeniami dla nowoczesnych frameworków:
Rozważania Praktyczne:
Według doświadczenia programistów:
Wpływ na Rozwój: Jeśli twoja aplikacja intensywnie korzysta z Bootstrap do jej interfejsu użytkownika i musisz generować raporty lub dokumenty, które pasują do twojego interfejsu webowego, bezproblemowe renderowanie IronPDF oszczędza znaczącą ilość czasu na rozwój. EvoPdf może wymagać tworzenia oddzielnych, uproszczonych wersji twoich szablonów specjalnie do generacji PDF.
Dla pełnych informacji na temat kompatybilności frameworków CSS, zobacz Przewodnik CSS Bootstrap & Flexbox.
IronPDF dostarcza kompleksową dokumentację, wsparcie inżynierów 24/5, samouczki wideo, forum społeczności i regularne aktualizacje. Ekosystem wsparcia obejmuje:
Jakość Dokumentacji:
Kanały Wsparcia:
Zasoby Edukacyjne:
EvoPdf zapewnia dokumentację i wsparcie poprzez:
Dokumentacja:
Opcje wsparcia:
Kluczowym czynnikiem wyróżniającym jest inwestycja IronPDF w treści edukacyjne i bezpośrednie wsparcie inżynieryjne, co znacznie skraca czas nauki i rozwiązywania problemów.
IronPDF doskonale sprawdza się w sytuacjach wymagających:
1. Integracja nowoczesnych aplikacji internetowych
2. Wymagania dotyczące zgodności i bezpieczeństwa
3. Przetwarzanie złożonych dokumentów
4. Wdrażanie wielopłatformowe
Przykład z życia: Generowanie raportów dotyczących opieki zdrowotnej
public class HealthcareReportGenerator
{
private readonly ChromePdfRenderer _renderer;
public HealthcareReportGenerator()
{
_renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
DPI = 300, // High quality for medical imaging
EnableJavaScript = true,
RenderDelay = 3000, // Allow charts to fully render
CreatePdfFormsFromHtml = true
}
};
}
public async Task<byte[]> GeneratePatientReport(PatientData patient)
{
// Generate HTML with patient data and charts
var html = await GenerateReportHtml(patient);
// Convert to PDF
var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
// Apply security and compliance
pdf.SecuritySettings = new SecuritySettings
{
AllowPrint = true,
AllowCopy = false,
EncryptionLevel = EncryptionLevel.AES256Bit,
UserPassword = patient.AccessCode
};
// Redact SSN except last 4 digits
pdf.RedactTextOnAllPages(@"\b\d{3}-\d{2}-(\d{4})\b",
replacement: "XXX-XX-$1",
isRegex: true);
// Add audit metadata
pdf.MetaData.Author = "Healthcare System";
pdf.MetaData.Title = $"Patient Report - {patient.PatientId}";
pdf.MetaData.CreationDate = DateTime.UtcNow;
pdf.MetaData.CustomProperties.Add("HIPAA_Compliant", "true");
// Add digital signature
var signature = new PdfSignature("hospital-cert.pfx", "password")
{
SigningReason = "Medical Record Authenticity",
SigningLocation = "Hospital Name"
};
pdf.Sign(signature);
return pdf.BinaryData;
}
}Public Class HealthcareReportGenerator
Private ReadOnly _renderer As ChromePdfRenderer
Public Sub New()
_renderer = New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.DPI = 300, ' High quality for medical imaging
.EnableJavaScript = True,
.RenderDelay = 3000, ' Allow charts to fully render
.CreatePdfFormsFromHtml = True
}
}
End Sub
Public Async Function GeneratePatientReport(patient As PatientData) As Task(Of Byte())
' Generate HTML with patient data and charts
Dim html = Await GenerateReportHtml(patient)
' Convert to PDF
Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(html)
' Apply security and compliance
pdf.SecuritySettings = New SecuritySettings With {
.AllowPrint = True,
.AllowCopy = False,
.EncryptionLevel = EncryptionLevel.AES256Bit,
.UserPassword = patient.AccessCode
}
' Redact SSN except last 4 digits
pdf.RedactTextOnAllPages("\b\d{3}-\d{2}-(\d{4})\b",
replacement:="XXX-XX-$1",
isRegex:=True)
' Add audit metadata
pdf.MetaData.Author = "Healthcare System"
pdf.MetaData.Title = $"Patient Report - {patient.PatientId}"
pdf.MetaData.CreationDate = DateTime.UtcNow
pdf.MetaData.CustomProperties.Add("HIPAA_Compliant", "true")
' Add digital signature
Dim signature = New PdfSignature("hospital-cert.pfx", "password") With {
.SigningReason = "Medical Record Authenticity",
.SigningLocation = "Hospital Name"
}
pdf.Sign(signature)
Return pdf.BinaryData
End Function
End ClassEvoPdf doskonale nadaje się do:
1. Prosta konwersja HTML do PDF
2. Zespoły dbające o budżet
3. Konkretne środowiska serwerowe
4. Proste konwersje o dużej objętości
Przykład z życia: System generowania faktur
public class InvoiceGenerator
{
private readonly HtmlToPdfConverter _converter;
public InvoiceGenerator()
{
_converter = new HtmlToPdfConverter
{
LicenseKey = "your-license-key",
JavaScriptEnabled = false, // Not needed for static invoices
ConversionDelay = 0
};
// Configure for A4 invoices
_converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
_converter.PdfDocumentOptions.TopMargin = 30;
_converter.PdfDocumentOptions.BottomMargin = 30;
}
public byte[] GenerateInvoice(InvoiceData data)
{
// Load HTML template
var template = File.ReadAllText("invoice-template.html");
// Simple string replacement for data
var html = template
.Replace("{{InvoiceNumber}}", data.InvoiceNumber)
.Replace("{{Date}}", data.Date.ToString("yyyy-MM-dd"))
.Replace("{{CustomerName}}", data.CustomerName)
.Replace("{{Total}}", data.Total.ToString("C"));
// Convert to PDF
return _converter.ConvertHtml(html, "");
}
}Public Class InvoiceGenerator
Private ReadOnly _converter As HtmlToPdfConverter
Public Sub New()
_converter = New HtmlToPdfConverter With {
.LicenseKey = "your-license-key",
.JavaScriptEnabled = False, ' Not needed for static invoices
.ConversionDelay = 0
}
' Configure for A4 invoices
_converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4
_converter.PdfDocumentOptions.TopMargin = 30
_converter.PdfDocumentOptions.BottomMargin = 30
End Sub
Public Function GenerateInvoice(data As InvoiceData) As Byte()
' Load HTML template
Dim template = File.ReadAllText("invoice-template.html")
' Simple string replacement for data
Dim html = template _
.Replace("{{InvoiceNumber}}", data.InvoiceNumber) _
.Replace("{{Date}}", data.Date.ToString("yyyy-MM-dd")) _
.Replace("{{CustomerName}}", data.CustomerName) _
.Replace("{{Total}}", data.Total.ToString("C"))
' Convert to PDF
Return _converter.ConvertHtml(html, "")
End Function
End ClassObie biblioteki działają najlepiej przy odpowiedniej konfiguracji i wzorcach użytkowania:
public class OptimizedPdfService
{
private readonly ChromePdfRenderer _renderer;
private readonly SemaphoreSlim _semaphore;
public OptimizedPdfService(int maxConcurrency = 4)
{
_semaphore = new SemaphoreSlim(maxConcurrency);
_renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
// Optimize for performance
EnableJavaScript = false, // Only if not needed
RenderDelay = 0,
DPI = 150, // Balance quality vs speed
CssMediaType = PdfCssMediaType.Screen,
Timeout = 30,
// Memory optimization
OptimizeForLowMemory = true
}
};
// Enable connection pooling
Installation.ChromeGpuMode = ChromeGpuModes.Disabled;
Installation.LinuxAndDockerDependenciesAutoConfig = false;
}
public async Task<byte[]> GeneratePdfAsync(string html)
{
await _semaphore.WaitAsync();
try
{
var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
// Optimize file size
pdf.CompressImages(85);
pdf.RemoveUnusedResources();
return pdf.BinaryData;
}
finally
{
_semaphore.Release();
}
}
}Public Class OptimizedPdfService
Private ReadOnly _renderer As ChromePdfRenderer
Private ReadOnly _semaphore As SemaphoreSlim
Public Sub New(Optional maxConcurrency As Integer = 4)
_semaphore = New SemaphoreSlim(maxConcurrency)
_renderer = New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.EnableJavaScript = False, ' Only if not needed
.RenderDelay = 0,
.DPI = 150, ' Balance quality vs speed
.CssMediaType = PdfCssMediaType.Screen,
.Timeout = 30,
.OptimizeForLowMemory = True
}
}
' Enable connection pooling
Installation.ChromeGpuMode = ChromeGpuModes.Disabled
Installation.LinuxAndDockerDependenciesAutoConfig = False
End Sub
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
Await _semaphore.WaitAsync()
Try
Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(html)
' Optimize file size
pdf.CompressImages(85)
pdf.RemoveUnusedResources()
Return pdf.BinaryData
Finally
_semaphore.Release()
End Try
End Function
End Classpublic class EvoPdfOptimizedService
{
private readonly ObjectPool<HtmlToPdfConverter> _converterPool;
public EvoPdfOptimizedService()
{
// Create object pool for converter reuse
_converterPool = new DefaultObjectPool<HtmlToPdfConverter>(
new ConverterPoolPolicy(),
Environment.ProcessorCount * 2);
}
public async Task<byte[]> GeneratePdfAsync(string html)
{
var converter = _converterPool.Get();
try
{
// Configure for speed
converter.ConversionDelay = 0;
converter.JavaScriptEnabled = false;
// Use async pattern
return await Task.Run(() => converter.ConvertHtml(html, ""));
}
finally
{
_converterPool.Return(converter);
}
}
private class ConverterPoolPolicy : IPooledObjectPolicy<HtmlToPdfConverter>
{
public HtmlToPdfConverter Create()
{
return new HtmlToPdfConverter
{
LicenseKey = "your-license-key"
};
}
public bool Return(HtmlToPdfConverter obj)
{
// Reset to default state
obj.ConversionDelay = 2;
return true;
}
}
}Public Class EvoPdfOptimizedService
Private ReadOnly _converterPool As ObjectPool(Of HtmlToPdfConverter)
Public Sub New()
' Create object pool for converter reuse
_converterPool = New DefaultObjectPool(Of HtmlToPdfConverter)(
New ConverterPoolPolicy(),
Environment.ProcessorCount * 2)
End Sub
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
Dim converter = _converterPool.Get()
Try
' Configure for speed
converter.ConversionDelay = 0
converter.JavaScriptEnabled = False
' Use async pattern
Return Await Task.Run(Function() converter.ConvertHtml(html, ""))
Finally
_converterPool.Return(converter)
End Try
End Function
Private Class ConverterPoolPolicy
Implements IPooledObjectPolicy(Of HtmlToPdfConverter)
Public Function Create() As HtmlToPdfConverter Implements IPooledObjectPolicy(Of HtmlToPdfConverter).Create
Return New HtmlToPdfConverter With {
.LicenseKey = "your-license-key"
}
End Function
Public Function Return(obj As HtmlToPdfConverter) As Boolean Implements IPooledObjectPolicy(Of HtmlToPdfConverter).Return
' Reset to default state
obj.ConversionDelay = 2
Return True
End Function
End Class
End ClassSolidna obsługa błędów ma kluczowe znaczenie dla aplikacji produkcyjnych:
public class RobustPdfGenerator
{
private readonly ILogger<RobustPdfGenerator> _logger;
private readonly ChromePdfRenderer _renderer;
public async Task<Result<byte[]>> TryGeneratePdfAsync(string html)
{
try
{
// Enable detailed logging
IronPdf.Logging.Logger.EnableDebugging = true;
IronPdf.Logging.Logger.LogFilePath = "ironpdf.log";
IronPdf.Logging.Logger.LoggingLevel = LoggingLevels.All;
var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
// Validate output
if (pdf.PageCount == 0)
{
return Result<byte[]>.Failure("Generated PDF has no pages");
}
return Result<byte[]>.Success(pdf.BinaryData);
}
catch (IronPdf.Exceptions.IronPdfRenderException ex)
{
_logger.LogError(ex, "Rendering failed: {Message}", ex.Message);
// Attempt fallback with simpler settings
return await FallbackRender(html);
}
catch (Exception ex)
{
_logger.LogError(ex, "Unexpected error in PDF generation");
return Result<byte[]>.Failure($"PDF generation failed: {ex.Message}");
}
}
private async Task<Result<byte[]>> FallbackRender(string html)
{
var fallbackRenderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
EnableJavaScript = false,
DPI = 96,
Timeout = 60
}
};
try
{
var pdf = await fallbackRenderer.RenderHtmlAsPdfAsync(html);
return Result<byte[]>.Success(pdf.BinaryData);
}
catch (Exception ex)
{
return Result<byte[]>.Failure($"Fallback render failed: {ex.Message}");
}
}
}Public Class RobustPdfGenerator
Private ReadOnly _logger As ILogger(Of RobustPdfGenerator)
Private ReadOnly _renderer As ChromePdfRenderer
Public Async Function TryGeneratePdfAsync(html As String) As Task(Of Result(Of Byte()))
Try
' Enable detailed logging
IronPdf.Logging.Logger.EnableDebugging = True
IronPdf.Logging.Logger.LogFilePath = "ironpdf.log"
IronPdf.Logging.Logger.LoggingLevel = LoggingLevels.All
Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(html)
' Validate output
If pdf.PageCount = 0 Then
Return Result(Of Byte()).Failure("Generated PDF has no pages")
End If
Return Result(Of Byte()).Success(pdf.BinaryData)
Catch ex As IronPdf.Exceptions.IronPdfRenderException
_logger.LogError(ex, "Rendering failed: {Message}", ex.Message)
' Attempt fallback with simpler settings
Return Await FallbackRender(html)
Catch ex As Exception
_logger.LogError(ex, "Unexpected error in PDF generation")
Return Result(Of Byte()).Failure($"PDF generation failed: {ex.Message}")
End Try
End Function
Private Async Function FallbackRender(html As String) As Task(Of Result(Of Byte()))
Dim fallbackRenderer = New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.EnableJavaScript = False,
.DPI = 96,
.Timeout = 60
}
}
Try
Dim pdf = Await fallbackRenderer.RenderHtmlAsPdfAsync(html)
Return Result(Of Byte()).Success(pdf.BinaryData)
Catch ex As Exception
Return Result(Of Byte()).Failure($"Fallback render failed: {ex.Message}")
End Try
End Function
End ClassInstytucje finansowe wymagają określonych funkcji w celu zapewnienia zgodności z przepisami:
public class FinancialStatementGenerator
{
public async Task<byte[]> GenerateQuarterlyReport(FinancialData data)
{
var renderer = new ChromePdfRenderer();
// Generate report with charts and tables
var html = await BuildFinancialReportHtml(data);
var pdf = renderer.RenderHtmlAsPdf(html);
// Add compliance watermark
pdf.ApplyWatermark(@"
<div style='text-align: center; color: rgba(0,0,0,0.1); font-size: 120px;
transform: rotate(-45deg); font-family: Arial;'>
DRAFT
</div>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center);
// Embed audit information
pdf.MetaData.Author = "Financial Reporting System";
pdf.MetaData.Keywords = "Quarterly Report, SOX Compliant";
pdf.MetaData.CustomProperties.Add("ReportPeriod", data.Quarter);
pdf.MetaData.CustomProperties.Add("GeneratedBy", Environment.UserName);
pdf.MetaData.CustomProperties.Add("Timestamp", DateTime.UtcNow.ToString("O"));
// Apply tamper-evident signature
var cert = new X509Certificate2("financial-cert.pfx", "password");
var signature = new PdfSignature(cert)
{
SigningReason = "Financial Report Certification",
SigningLocation = "Corporate Finance Department",
IsVisible = true,
SignatureImage = new PdfSignatureImage("cfo-signature.png")
};
pdf.Sign(signature);
// Lock document from editing
pdf.SecuritySettings = new SecuritySettings
{
AllowModifyDocument = false,
AllowCopy = true,
AllowPrint = true,
EncryptionLevel = EncryptionLevel.AES256Bit
};
return pdf.BinaryData;
}
}Public Class FinancialStatementGenerator
Public Async Function GenerateQuarterlyReport(data As FinancialData) As Task(Of Byte())
Dim renderer = New ChromePdfRenderer()
' Generate report with charts and tables
Dim html = Await BuildFinancialReportHtml(data)
Dim pdf = renderer.RenderHtmlAsPdf(html)
' Add compliance watermark
pdf.ApplyWatermark("
<div style='text-align: center; color: rgba(0,0,0,0.1); font-size: 120px;
transform: rotate(-45deg); font-family: Arial;'>
DRAFT
</div>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center)
' Embed audit information
pdf.MetaData.Author = "Financial Reporting System"
pdf.MetaData.Keywords = "Quarterly Report, SOX Compliant"
pdf.MetaData.CustomProperties.Add("ReportPeriod", data.Quarter)
pdf.MetaData.CustomProperties.Add("GeneratedBy", Environment.UserName)
pdf.MetaData.CustomProperties.Add("Timestamp", DateTime.UtcNow.ToString("O"))
' Apply tamper-evident signature
Dim cert = New X509Certificate2("financial-cert.pfx", "password")
Dim signature = New PdfSignature(cert) With {
.SigningReason = "Financial Report Certification",
.SigningLocation = "Corporate Finance Department",
.IsVisible = True,
.SignatureImage = New PdfSignatureImage("cfo-signature.png")
}
pdf.Sign(signature)
' Lock document from editing
pdf.SecuritySettings = New SecuritySettings With {
.AllowModifyDocument = False,
.AllowCopy = True,
.AllowPrint = True,
.EncryptionLevel = EncryptionLevel.AES256Bit
}
Return pdf.BinaryData
End Function
End ClassPlatformy e-commerce potrzebują szybkiego i niezawodnego generowania faktur:
public class EcommerceInvoiceService
{
private readonly ChromePdfRenderer _renderer;
public EcommerceInvoiceService()
{
_renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
MarginTop = 10,
MarginBottom = 10,
PaperSize = PdfPaperSize.A4,
DPI = 200 // High quality for barcodes
}
};
}
public async Task<byte[]> GenerateInvoice(Order order)
{
// Build invoice HTML with order details
var html = $@"
<html>
<head>
<style>
@page {{size: A4; margin: 0;}}
body {{font-family: Arial, sans-serif;}}
.invoice-header {{background: #f0f0f0; padding: 20px;}}
.barcode {{text-align: center; margin: 20px 0;}}
table {{width: 100%; border-collapse: collapse;}}
th, td {{padding: 10px; border-bottom: 1px solid #ddd;}}
</style>
</head>
<body>
<div class='invoice-header'>
<h1>Invoice #{order.InvoiceNumber}</h1>
<p>Date: {order.Date:yyyy-MM-dd}</p>
</div>
<div class='barcode'>
<img src='data:image/png;base64,{GenerateBarcode(order.InvoiceNumber)}' />
</div>
<table>
<tr>
<th>Item</th>
<th>Quantity</th>
<th>Price</th>
<th>Total</th>
</tr>
{string.Join("", order.Items.Select(item => $@"
<tr>
<td>{item.Name}</td>
<td>{item.Quantity}</td>
<td>${item.Price:F2}</td>
<td>${item.Total:F2}</td>
</tr>"))}
<tr>
<td colspan='3'><strong>Total</strong></td>
<td><strong>${order.Total:F2}</strong></td>
</tr>
</table>
<div class='footer'>
<p>Thank you for your business!</p>
<p>Return policy and terms at: www.example.com/terms</p>
</div>
</body>
</html>";
var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
// Add QR code for mobile payment verification
var qrStamper = new ImageStamper($"https://api.qrserver.com/v1/create-qr-code/?data={order.PaymentId}")
{
HorizontalAlignment = HorizontalAlignment.Right,
VerticalAlignment = VerticalAlignment.Bottom,
Width = 100,
Height = 100
};
pdf.ApplyStamp(qrStamper);
return pdf.BinaryData;
}
}Jeśli rozważasz zmianę biblioteki, oto podejście do migracji:
// EvoPdf pattern
HtmlToPdfConverter evoPdfConverter = new HtmlToPdfConverter();
evoPdfConverter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
byte[] pdfBytes = evoPdfConverter.ConvertUrl(url);
// Equivalent IronPDF pattern
var ironPdfRenderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
PaperSize = PdfPaperSize.A4
}
};
var pdf = ironPdfRenderer.RenderUrlAsPdf(url);
byte[] pdfBytes = pdf.BinaryData;
// Migration wrapper for gradual transition
public interface IPdfConverter
{
byte[] ConvertHtmlToPdf(string html);
byte[] ConvertUrlToPdf(string url);
}
public class IronPdfAdapter : IPdfConverter
{
private readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();
public byte[] ConvertHtmlToPdf(string html)
{
return _renderer.RenderHtmlAsPdf(html).BinaryData;
}
public byte[] ConvertUrlToPdf(string url)
{
return _renderer.RenderUrlAsPdf(url).BinaryData;
}
}
public class EvoPdfAdapter : IPdfConverter
{
private readonly HtmlToPdfConverter _converter = new HtmlToPdfConverter();
public byte[] ConvertHtmlToPdf(string html)
{
return _converter.ConvertHtml(html, "");
}
public byte[] ConvertUrlToPdf(string url)
{
return _converter.ConvertUrl(url);
}
}' EvoPdf pattern
Dim evoPdfConverter As New HtmlToPdfConverter()
evoPdfConverter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4
Dim pdfBytes As Byte() = evoPdfConverter.ConvertUrl(url)
' Equivalent IronPDF pattern
Dim ironPdfRenderer As New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.PaperSize = PdfPaperSize.A4
}
}
Dim pdf = ironPdfRenderer.RenderUrlAsPdf(url)
Dim pdfBytes As Byte() = pdf.BinaryData
' Migration wrapper for gradual transition
Public Interface IPdfConverter
Function ConvertHtmlToPdf(html As String) As Byte()
Function ConvertUrlToPdf(url As String) As Byte()
End Interface
Public Class IronPdfAdapter
Implements IPdfConverter
Private ReadOnly _renderer As New ChromePdfRenderer()
Public Function ConvertHtmlToPdf(html As String) As Byte() Implements IPdfConverter.ConvertHtmlToPdf
Return _renderer.RenderHtmlAsPdf(html).BinaryData
End Function
Public Function ConvertUrlToPdf(url As String) As Byte() Implements IPdfConverter.ConvertUrlToPdf
Return _renderer.RenderUrlAsPdf(url).BinaryData
End Function
End Class
Public Class EvoPdfAdapter
Implements IPdfConverter
Private ReadOnly _converter As New HtmlToPdfConverter()
Public Function ConvertHtmlToPdf(html As String) As Byte() Implements IPdfConverter.ConvertHtmlToPdf
Return _converter.ConvertHtml(html, "")
End Function
Public Function ConvertUrlToPdf(url As String) As Byte() Implements IPdfConverter.ConvertUrlToPdf
Return _converter.ConvertUrl(url)
End Function
End ClassZarówno IronPDF, jak i EvoPdf odgrywają ważną rolę w ekosystemie bibliotek PDF dla platformy .NET, ale są przeznaczone do różnych zastosowań i opierają się na różnych filozofiach programowania.
Wybierz IronPDF, jeśli potrzebujesz:
Wybierz EvoPdf, jeśli potrzebujesz:
Ostateczna decyzja zależy od konkretnych wymagań, ograniczeń budżetowych oraz długoterminowych potrzeb w zakresie skalowalności. Dla większości nowoczesnych aplikacji wymagających solidnych możliwości PDF, kompleksowy zestaw funkcji IronPDF i silnik renderujący oparty na Chrome czyni go silną inwestycją. Jednak EvoPdf pozostaje realną opcją w prostszych przypadkach użycia, gdzie głównym czynnikiem jest koszt.
Rozważ rozpoczęcie od 30-dniowego okresu próbnego IronPDF, aby ocenić jego możliwości w konkretnym przypadku użycia. Wersja próbna daje dostęp do funkcji IronPDF, pozwalając podjąć świadomą decyzję na podstawie faktycznej wydajności w twoim środowisku.
Należy pamiętać, że rzeczywisty koszt biblioteki PDF wykracza poza cenę licencji — należy uwzględnić czas rozwoju, koszty utrzymania oraz potencjalną potrzebę wprowadzenia dodatkowych funkcji w miarę rozwoju aplikacji. Wybierz bibliotekę, która nie tylko spełnia Twoje obecne potrzeby, ale także może skalować się wraz z przyszłymi wymaganiami.
Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczącą ponad 50 osób, obsługującą NASA, Teslę i światowe agencje rządowe.
IronPDF jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
Kiedy potrzebujesz, aby twój PDF wyglądał jak HTML, szybko.
