IronPDF oferuje pełne możliwości przeglądania PDF w języku C# dzięki swojej intuicyjnej API i konwersji HTML-do-PDF za pomocą silnika renderującego opartego na Chrome, podczas gdy PDFSharp zapewnia podstawową open-source manipulację PDF wymagającą znacznie bardziej złożonego kodu do ekstrakcji tekstu i zadań przeglądania.
W tworzeniu oprogramowania kluczowe znaczenie ma obsługa danych w różnych formatach. PDF (Portable Document Format) to powszechnie stosowany standard udostępniania dokumentów. W programowaniu w języku C# przeglądanie plików PDF jest niezbędne do tworzenia profesjonalnych dokumentów i zarządzania treściami cyfrowymi. Biblioteka IronPDF zapewnia kompletne narzędzia do generowania i edycji plików PDF.
Wszechstronność języka C# sprawia, że jest on popularny przy tworzeniu aplikacji w różnych dziedzinach. PDF zapewnia integralność dokumentu i spójny wygląd na różnych platformach. Włączenie funkcji przeglądania plików PDF do aplikacji pozwala poprawić komfort użytkowania, uprościć przepływ pracy i zapewnić wydajne rozwiązania do obsługi dokumentów. W przypadku aplikacji wymagających rozpoznawania tekstu ze skanowanych dokumentów, uzupełniające rozwiązania OCR mogą poprawić możliwości przetwarzania plików PDF. Dokumentacja IronPDF zawiera kompletne przewodniki wdrożeniowe. Podczas pracy z dokumentami poufnymi kluczowe znaczenie ma właściwa obsługa plików PDF.
Artykuł ten bada przeglądanie PDF za pomocą C#, wprowadza dwie biblioteki - PDFSharp i IronPDF - i dostarcza instrukcji dotyczących instalacji i użytkowania. Przeanalizujesz różnice architektoniczne, złożoność kodu oraz kwestie związane z utrzymaniem, które mają wpływ na wybór między tymi rozwiązaniami do generowania plików PDF. W środowiskach wymagających bezpieczeństwa dokumentów zrozumienie tych różnic ma kluczowe znaczenie. Prezentacje IronPDF pokazują rzeczywiste wdrożenia, a Dokumentacja API zawiera szczegółowe specyfikacje.
PDFSharp to open-source biblioteka dla C# oferująca deweloperom zestaw narzędzi do manipulacji PDF. W przeciwieństwie do silnika renderującego opartego na Chrome IronPDF, PDFSharp operuje na niskopoziomowym modelu rysowania, zapewniając bezpośrednią kontrolę nad prymitywami PDF. Biblioteka umożliwia dostęp do struktur dokumentów PDF oraz manipulowanie nimi. Jednakże, w porównaniu do pełnych funkcji IronPDF, PDFSharp wymaga znacznie więcej ręcznego kodowania dla typowych zadań.
Architektura PDFSharp opiera się na podejściu dokument-obiekt, w którym pracujesz bezpośrednio z obiektami PDF. Różni się to od podejścia IronPDF do konwersji HTML na PDF, które wykorzystuje technologie internetowe do generowania dokumentów. Podczas gdy PDFSharp exceluje w tworzeniu pustych PDF i operacjach rysowania, wymaga więcej kodu do zadań takich jak dodawanie nagłówków czy osadzanie obrazów. Zaawansowane funkcje, takie jak renderowanie JavaScript, obsługa responsywnego CSS oraz integracja czcionek internetowych nie są dostępne w PDFSharp.
Podobnie jak proces instalacji IronPDF, PDFSharp można zainstalować za pomocą NuGet. Wykonaj następujące polecenie:
To polecenie instaluje bibliotekę PDFSharp do użycia w twoim projekcie. W przeciwieństwie do zaawansowanych opcji instalacji IronPDF, PDFSharp nie ma wbudowanego wsparcia dla kontenerów Docker czy wdrożeń na Linux. Przewodnik szybkiego startu zawiera dodatkowe instrukcje dotyczące konfiguracji IronPDF.
PDFSharp jest skierowany na starsze wersje .NET Framework i może napotkać problemy z kompatybilnością z nowszymi wersjami .NET oraz środowiskami chmurowymi. Biblioteka wymaga ręcznej konfiguracji w celu wdrożenia na wielu platformach, w przeciwieństwie do automatycznego wykrywania platformy przez IronPDF. Wzorce użycia pamięci różnią się, przy czym PDFSharp może zużywać więcej zasobów dla złożonych operacji. W scenariuszach wymagających wysokiej wydajności różnice te stają się zauważalne. Przewodnik optymalizacji wydajności IronPDF zapewnia strategie niedostępne w PDFSharp.
Niskopoziomowa architektura PDFSharp wpływa na wydajność poprzez bezpośrednią manipulację obiektami PDF, wymagającą więcej cykli CPU. Biblioteka nie jest zoptymalizowana pod kątem przetwarzania wsadowego, operacji równoległych ani asynchronicznych przepływów pracy. Wydajność ekstrakcji tekstu spada w przypadku złożonych dokumentów ze względu na ręczne parsowanie przez operatora. Silnik IronPDF oparty na przeglądarce Chrome wykorzystuje techniki optymalizacji przeglądarki, co skutkuje szybszym renderowaniem i lepszą wydajnością pamięci. W przypadku operacji asynchronicznych architektura IronPDF zapewnia znaczące korzyści.
IronPDF to bogata w funkcje biblioteka, która pozwala z łatwością manipulować plikami PDF. Zaprojektowany z myślą o prostocie i wszechstronności, IronPDF pozwala tworzyć, edytować i odczytywać dokumenty PDF w ramach aplikacji. Oprócz podstawowych możliwości, IronPDF oferuje zaawansowane funkcje, takie jak konwersja HTML do PDF, obsługa różnych formatów obrazów oraz wydajne przetwarzanie operacji związanych z plikami PDF. Biblioteka doskonale sprawdza się w generowaniu raportów PDF i konwersji różnych formatów plików.
Podstawą architektury IronPDF jest silnik renderujący Chrome, który zapewnia idealne odwzorowanie treści internetowych. Takie podejście upraszcza typowe zadania, takie jak zarządzanie czcionkami, obsługa JavaScript oraz obsługa znaków UTF-8. Biblioteka obsługuje linearyzację, kompresję plików PDF, podpisy cyfrowe i adnotacje.
IronPDF obsługuje pliki PDF i formatuje dane, oferując wsparcie dla ekstrakcji metadanych oraz operacji asynchronicznych. W przypadku aplikacji Blazor IronPDF zapewnia płynną integrację.
Zainstaluj IronPDF za pomocą menedżera pakietów NuGet lub konsoli menedżera pakietów:
To polecenie instaluje IronPDF i jego zależności. W przypadku wdrożeń Docker lub środowisk Linux mogą być wymagane dodatkowe pakiety. Przewodnik szybkiego startu zawiera instrukcje dotyczące konfiguracji.
API IronPDF jest zgodne z nowoczesnymi wzorcami .NET, oferując płynne interfejsy i obsługę asynchroniczności. Biblioteka oferuje intuicyjne nazwy metod i pełną dokumentację IntelliSense. Komunikaty o błędach zawierają praktyczne rozwiązania, przyspieszające proces tworzenia oprogramowania. Dokumentacja API zawiera pełne informacje o metodach.
Użyj silnika IronPDF dla przeglądarki Chrome do konwersji responsywnych układów HTML, renderowania treści JavaScript lub przetwarzania nowoczesnych projektów CSS. Silnik automatycznie obsługuje czcionki internetowe, grafikę SVG i elementy Canvas. Idealnie nadaje się do generowania faktur z szablonów HTML lub tworzenia raportów z wizualizacjami. W celu renderowania treści WebGL silnik zapewnia przyspieszenie GPU.
Ta sekcja demonstruje przeglądanie plików PDF za pomocą PDFSharp. Ekstrakcja tekstu w PDFSharp jest złożona z powodu jego niskopoziomowej natury, w przeciwieństwie do prostych metod IronPDF:
using System;
using System.Text;
using PdfSharp.Pdf;
using PdfSharp.Pdf.IO;
using PdfSharp.Pdf.Content;
using PdfSharp.Pdf.Content.Objects;
class Program
{
static void Main()
{
// Specify the path to the PDF file
string pdfFilePath = "output.pdf";
// Open the PDF document in import mode
// Note: PDFsharp requires specific open modes for different operations
PdfDocument document = PdfReader.Open(pdfFilePath, PdfDocumentOpenMode.Import);
// Create StringBuilder for extracted text
// This approach is less efficient than IronPDF's built-in methods
StringBuilder extractedText = new StringBuilder();
// Iterate through each page of the document
for (int pageIndex = 0; pageIndex < document.PageCount; pageIndex++)
{
// Get the current page
PdfPage page = document.Pages[pageIndex];
// Extract text using content reader (simplified approach)
// Real implementation requires extensive operator parsing
CObject content = ContentReader.ReadContent(page);
// Parse content objects to extract text
// This is where PDFsharp becomes significantly complex
ExtractText(content, extractedText);
// Note: Actual text extraction requires parsing operators
// This is a simplified representation
Console.WriteLine($"Page {pageIndex + 1} processed");
}
Console.WriteLine("Extracted Text: " + extractedText.ToString());
Console.ReadLine(); // Wait for user input before closing the console
}
static void ExtractText(CObject content, StringBuilder text)
{
// PDFsharp requires manual parsing of content streams
// This is significantly more complex than shown here
// Real implementation would need to handle:
// - Text operators (Tj, TJ, ', ", etc.)
// - Font encoding and character mapping
// - Text positioning and transformation matrices
// - Unicode mapping and glyph substitution
// - Whitespace detection and word boundaries
if (content is CArray array)
{
foreach (var item in array)
{
ExtractText(item, text);
}
}
else if (content is CString str)
{
// Simplified text extraction - real implementation needs encoding handling
text.Append(str.Value);
}
// Additional operators would need handling for complete extraction
}
}Imports System
Imports System.Text
Imports PdfSharp.Pdf
Imports PdfSharp.Pdf.IO
Imports PdfSharp.Pdf.Content
Imports PdfSharp.Pdf.Content.Objects
Module Program
Sub Main()
' Specify the path to the PDF file
Dim pdfFilePath As String = "output.pdf"
' Open the PDF document in import mode
' Note: PDFsharp requires specific open modes for different operations
Dim document As PdfDocument = PdfReader.Open(pdfFilePath, PdfDocumentOpenMode.Import)
' Create StringBuilder for extracted text
' This approach is less efficient than IronPDF's built-in methods
Dim extractedText As New StringBuilder()
' Iterate through each page of the document
For pageIndex As Integer = 0 To document.PageCount - 1
' Get the current page
Dim page As PdfPage = document.Pages(pageIndex)
' Extract text using content reader (simplified approach)
' Real implementation requires extensive operator parsing
Dim content As CObject = ContentReader.ReadContent(page)
' Parse content objects to extract text
' This is where PDFsharp becomes significantly complex
ExtractText(content, extractedText)
' Note: Actual text extraction requires parsing operators
' This is a simplified representation
Console.WriteLine($"Page {pageIndex + 1} processed")
Next
Console.WriteLine("Extracted Text: " & extractedText.ToString())
Console.ReadLine() ' Wait for user input before closing the console
End Sub
Sub ExtractText(content As CObject, text As StringBuilder)
' PDFsharp requires manual parsing of content streams
' This is significantly more complex than shown here
' Real implementation would need to handle:
' - Text operators (Tj, TJ, ', ", etc.)
' - Font encoding and character mapping
' - Text positioning and transformation matrices
' - Unicode mapping and glyph substitution
' - Whitespace detection and word boundaries
If TypeOf content Is CArray Then
For Each item In DirectCast(content, CArray)
ExtractText(item, text)
Next
ElseIf TypeOf content Is CString Then
' Simplified text extraction - real implementation needs encoding handling
text.Append(DirectCast(content, CString).Value)
End If
' Additional operators would need handling for complete extraction
End Sub
End ModuleTen kod używa PDFSharp do czytania i ekstrakcji tekstu z pliku PDF. Program otwiera "output.pdf" w trybie importu i przebiega przez strony, aby wydobyć zawartość. W przeciwieństwie do prostego API IronPDF, to podejście wymaga zrozumienia wewnętrznej struktury plików PDF. Przykłady ekstrakcji tekstu z IronPDF pokazują prostsze podejście.
Złożoność PDFSharp wynika z jego niskopoziomowego podejścia. W przeciwieństwie do wysokopoziomowego API IronPDF, PDFSharp wymaga zrozumienia wnętrza PDF, w tym operatorów, kodowania i strumieni treści:
// PDFsharp: Complex font handling and text positioning
PdfDocument document = new PdfDocument();
PdfPage page = document.AddPage();
XGraphics gfx = XGraphics.FromPdfPage(page);
// Must manually specify fonts and handle font embedding
XFont font = new XFont("Arial", 12, XFontStyle.Regular);
// Manual text positioning with exact coordinates
gfx.DrawString("Hello World", font, XBrushes.Black,
new XRect(0, 0, page.Width, page.Height),
XStringFormats.Center);
// Must handle coordinate transformations manually
gfx.TranslateTransform(100, 200);
gfx.RotateTransform(45);
gfx.DrawString("Rotated Text", font, XBrushes.Red, 0, 0);
// IronPDF: Simple HTML approach with CSS styling
var renderer = new ChromePdfRenderer();
var doc = renderer.RenderHtmlAsPdf(@"
<h1 style='text-align: center;'>Hello World</h1>
<p style='transform: rotate(45deg); margin-left: 100px; margin-top: 200px; color: red;'>
Rotated Text
</p>");
// IronPDF automatically handles fonts, positioning, and transformations' PDFsharp: Complex font handling and text positioning
Dim document As New PdfDocument()
Dim page As PdfPage = document.AddPage()
Dim gfx As XGraphics = XGraphics.FromPdfPage(page)
' Must manually specify fonts and handle font embedding
Dim font As New XFont("Arial", 12, XFontStyle.Regular)
' Manual text positioning with exact coordinates
gfx.DrawString("Hello World", font, XBrushes.Black, New XRect(0, 0, page.Width, page.Height), XStringFormats.Center)
' Must handle coordinate transformations manually
gfx.TranslateTransform(100, 200)
gfx.RotateTransform(45)
gfx.DrawString("Rotated Text", font, XBrushes.Red, 0, 0)
' IronPDF: Simple HTML approach with CSS styling
Dim renderer As New ChromePdfRenderer()
Dim doc = renderer.RenderHtmlAsPdf("
<h1 style='text-align: center;'>Hello World</h1>
<p style='transform: rotate(45deg); margin-left: 100px; margin-top: 200px; color: red;'>
Rotated Text
</p>")
' IronPDF automatically handles fonts, positioning, and transformationsTa różnica architektoniczna ma znaczący wpływ na konserwację. PDFSharp wymaga więcej kodu szablonowego dla typowych zadań, takich jak dodawanie znaków wodnych czy zarządzanie orientacją stron.
Ograniczenia PDFSharp stają się oczywiste, gdy mamy do czynienia ze współczesnymi wymaganiami PDF:
PDFSharp ładuje całe pliki PDF do pamięci, co może powodować problemy z dużymi plikami. Przetwarzanie strumieniowe nie jest w pełni obsługiwane, co ogranicza skalowalność. W przeciwieństwie do ulepszonego pipeline renderowania IronPDF, PDFSharp nie ma wbudowanych mechanizmów buforowania. Przewodnik optymalizacji wydajności zapewnia strategie niedostępne w PDFSharp.
Wyświetlanie plików PDF za pomocą IronPDF wymaga zaledwie kilku wierszy kodu. Biblioteka automatycznie zarządza podstawowymi adresami URL i kodowaniem zasobów:
using IronPdf;
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
// Load the PDF document with error handling
var pdf = PdfDocument.FromFile("output.pdf");
// Extract all the text content from the PDF
string text = pdf.ExtractAllText();
// Print the extracted text to the console
Console.WriteLine("Full document text:");
Console.WriteLine(text);
// Additional extraction options demonstrating IronPDF's versatility
// Extract text from specific pages with formatting preserved
string pageText = pdf.ExtractTextFromPage(0);
Console.WriteLine($"\nPage 1 text: {pageText}");
// Extract all images and save them
var images = pdf.ExtractAllImages();
for (int i = 0; i < images.Count; i++)
{
images[i].SaveAs($"extracted_image_{i}.png");
}
// Access complete metadata
string author = pdf.MetaData.Author;
string title = pdf.MetaData.Title;
string subject = pdf.MetaData.Subject;
DateTime creationDate = pdf.MetaData.CreationDate;
Console.WriteLine($"\nDocument Info:");
Console.WriteLine($"Title: {title}");
Console.WriteLine($"Author: {author}");
Console.WriteLine($"Created: {creationDate}");
// Search for specific text
var searchResults = pdf.Search("invoice");
foreach (var result in searchResults)
{
Console.WriteLine($"Found '{result.Text}' on page {result.PageIndex}");
}
// Extract form field data
var form = pdf.Form;
foreach (var field in form.Fields)
{
Console.WriteLine($"Field: {field.Name} = {field.Value}");
}
}
}Imports IronPdf
Imports System
Imports System.Collections.Generic
Class Program
Shared Sub Main()
' Load the PDF document with error handling
Dim pdf = PdfDocument.FromFile("output.pdf")
' Extract all the text content from the PDF
Dim text As String = pdf.ExtractAllText()
' Print the extracted text to the console
Console.WriteLine("Full document text:")
Console.WriteLine(text)
' Additional extraction options demonstrating IronPDF's versatility
' Extract text from specific pages with formatting preserved
Dim pageText As String = pdf.ExtractTextFromPage(0)
Console.WriteLine(vbCrLf & "Page 1 text: " & pageText)
' Extract all images and save them
Dim images = pdf.ExtractAllImages()
For i As Integer = 0 To images.Count - 1
images(i).SaveAs($"extracted_image_{i}.png")
Next
' Access complete metadata
Dim author As String = pdf.MetaData.Author
Dim title As String = pdf.MetaData.Title
Dim subject As String = pdf.MetaData.Subject
Dim creationDate As DateTime = pdf.MetaData.CreationDate
Console.WriteLine(vbCrLf & "Document Info:")
Console.WriteLine("Title: " & title)
Console.WriteLine("Author: " & author)
Console.WriteLine("Created: " & creationDate)
' Search for specific text
Dim searchResults = pdf.Search("invoice")
For Each result In searchResults
Console.WriteLine($"Found '{result.Text}' on page {result.PageIndex}")
Next
' Extract form field data
Dim form = pdf.Form
For Each field In form.Fields
Console.WriteLine($"Field: {field.Name} = {field.Value}")
Next
End Sub
End ClassTen kod używa IronPDF do ekstrakcji tekstu z "output.pdf" za pomocą metody ExtractAllText. Implementacja automatycznie obsługuje złożoność PDF, zapewniając wyraźne korzyści w stosunku do ręcznego parsowania wymaganego przez PDFSharp. Twoja aplikacja może natychmiast używać tej funkcji bez zrozumienia wnętrza PDF. Pełny samouczek zawiera dodatkowe przykłady.
IronPDF zapewnia kompletne narzędzia do analizy plików PDF:
// Advanced PDF analysis with IronPDF
var pdf = PdfDocument.FromFile("complex-document.pdf");
// Extract structured content with detailed information
foreach (var page in pdf.Pages)
{
// Get page dimensions for layout analysis
var width = page.Width;
var height = page.Height;
var rotation = page.Rotation;
// Extract form fields with type information
var formFields = page.GetFormFields();
foreach (var field in formFields)
{
Console.WriteLine($"Field: {field.Name}, Type: {field.Type}, Value: {field.Value}");
}
// Extract annotations with properties
var annotations = page.GetAnnotations();
foreach (var annotation in annotations)
{
Console.WriteLine($"Annotation: {annotation.Title} - {annotation.Content}");
}
// Extract hyperlinks with destinations
var links = page.GetLinks();
foreach (var link in links)
{
Console.WriteLine($"Link: {link.Text} -> {link.Url}");
}
}
// Advanced search functionality with context
var searchResults = pdf.Search("invoice", SearchOptions.CaseInsensitive | SearchOptions.WholeWord);
foreach (var result in searchResults)
{
Console.WriteLine($"Found on page {result.PageIndex} at position {result.Position}: {result.Text}");
// Get surrounding text for context
string context = pdf.ExtractTextFromPage(result.PageIndex)
.Substring(Math.Max(0, result.Position - 50), 100);
Console.WriteLine($"Context: ...{context}...");
}
// Extract tables as structured data
var tables = pdf.ExtractTables();
foreach (var table in tables)
{
for (int row = 0; row < table.RowCount; row++)
{
for (int col = 0; col < table.ColumnCount; col++)
{
Console.Write($"{table[row, col]}\t");
}
Console.WriteLine();
}
}' Advanced PDF analysis with IronPDF
Dim pdf = PdfDocument.FromFile("complex-document.pdf")
' Extract structured content with detailed information
For Each page In pdf.Pages
' Get page dimensions for layout analysis
Dim width = page.Width
Dim height = page.Height
Dim rotation = page.Rotation
' Extract form fields with type information
Dim formFields = page.GetFormFields()
For Each field In formFields
Console.WriteLine($"Field: {field.Name}, Type: {field.Type}, Value: {field.Value}")
Next
' Extract annotations with properties
Dim annotations = page.GetAnnotations()
For Each annotation In annotations
Console.WriteLine($"Annotation: {annotation.Title} - {annotation.Content}")
Next
' Extract hyperlinks with destinations
Dim links = page.GetLinks()
For Each link In links
Console.WriteLine($"Link: {link.Text} -> {link.Url}")
Next
Next
' Advanced search functionality with context
Dim searchResults = pdf.Search("invoice", SearchOptions.CaseInsensitive Or SearchOptions.WholeWord)
For Each result In searchResults
Console.WriteLine($"Found on page {result.PageIndex} at position {result.Position}: {result.Text}")
' Get surrounding text for context
Dim context As String = pdf.ExtractTextFromPage(result.PageIndex).Substring(Math.Max(0, result.Position - 50), 100)
Console.WriteLine($"Context: ...{context}...")
Next
' Extract tables as structured data
Dim tables = pdf.ExtractTables()
For Each table In tables
For row As Integer = 0 To table.RowCount - 1
For col As Integer = 0 To table.ColumnCount - 1
Console.Write($"{table(row, col)}" & vbTab)
Next
Console.WriteLine()
Next
NextFunkcje te są niezbędne w aplikacjach Enterprise zajmujących się przetwarzaniem formularzy lub wymogąmi zgodności. IronPDF obsługuje konwersję do formatu PDF/A oraz standardy dostępności PDF/UA.
Twój wybór między IronPDF a PDFSharp zależy od wymagań projektu:
Wybierz IronPDF, gdy:
Rozważ PDFSharp, gdy:
IronPDF wyróżnia się możliwością przetwarzania na skalę Enterprise dzięki wbudowanej optymalizacji. Biblioteka obsługuje przetwarzanie równoległe, operacje wsadowe oraz strumieniowanie oszczędzające pamięć. Metody asynchroniczne umożliwiają wykonywanie operacji nieblokujących w aplikacjach internetowych. Silnik IronPDF dla przeglądarki Chrome efektywnie obsługuje równoczesne żądania, dzięki czemu nadaje się do mikrousług i funkcji bezserwerowych.
Zarówno PDFSharp, jak i IronPDF oferują funkcje dla deweloperów poszukujących wszechstronnych rozwiązań. PDFSharp oferuje lekkie narzędzie odpowiednie do podstawowych zadań PDF. Natomiast IronPDF jest przeznaczony do kompleksowej obsługi plików PDF. Jego zaawansowane funkcje sprawiają, że jest on skuteczny w przypadku zaawansowanych operacji na plikach PDF.
Rozważmy poniższy przykład kodu ilustrujący przejrzystą architekturę IronPDF:
// IronPDF: Clean, maintainable code following SOLID principles
public class InvoiceService
{
private readonly ITemplateEngine _templateEngine;
private readonly IConfiguration _config;
public async Task<byte[]> GenerateInvoicePdf(Invoice invoice)
{
// Render HTML from template with full CSS support
var html = await _templateEngine.RenderAsync("invoice.html", invoice);
// Configure rendering with fluent API
var renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
MarginTop = 50,
MarginBottom = 50,
PaperSize = PdfPaperSize.A4,
Title = $"Invoice #{invoice.Number}",
// Enable JavaScript for dynamic content
EnableJavaScript = true,
// Wait for AJAX calls to complete
WaitFor = WaitFor.NetworkIdle0,
// Custom headers and footers
HtmlHeader = "<div style='text-align: center;'>{page} of {total-pages}</div>",
HtmlFooter = "<div style='text-align: center;'>© 2024 Your Company</div>"
}
};
// Render with full Chrome engine support
var pdf = await renderer.RenderHtmlAsPdfAsync(html);
// Add security features
pdf.SecuritySettings.SetPassword("user-password", "owner-password");
pdf.SecuritySettings.AllowPrinting = true;
pdf.SecuritySettings.AllowCopy = false;
// Add digital signature for authenticity
pdf.SignWithCertificate(certificate, "Authorized Signature");
// Improve for web delivery
pdf.CompressImages(90);
return pdf.BinaryData;
}
}' IronPDF: Clean, maintainable code following SOLID principles
Public Class InvoiceService
Private ReadOnly _templateEngine As ITemplateEngine
Private ReadOnly _config As IConfiguration
Public Async Function GenerateInvoicePdf(invoice As Invoice) As Task(Of Byte())
' Render HTML from template with full CSS support
Dim html = Await _templateEngine.RenderAsync("invoice.html", invoice)
' Configure rendering with fluent API
Dim renderer = New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.MarginTop = 50,
.MarginBottom = 50,
.PaperSize = PdfPaperSize.A4,
.Title = $"Invoice #{invoice.Number}",
' Enable JavaScript for dynamic content
.EnableJavaScript = True,
' Wait for AJAX calls to complete
.WaitFor = WaitFor.NetworkIdle0,
' Custom headers and footers
.HtmlHeader = "<div style='text-align: center;'>{page} of {total-pages}</div>",
.HtmlFooter = "<div style='text-align: center;'>© 2024 Your Company</div>"
}
}
' Render with full Chrome engine support
Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)
' Add security features
pdf.SecuritySettings.SetPassword("user-password", "owner-password")
pdf.SecuritySettings.AllowPrinting = True
pdf.SecuritySettings.AllowCopy = False
' Add digital signature for authenticity
pdf.SignWithCertificate(certificate, "Authorized Signature")
' Improve for web delivery
pdf.CompressImages(90)
Return pdf.BinaryData
End Function
End ClassTakie podejście zapewnia wyraźne korzyści dzięki wykorzystaniu istniejących umiejętności w zakresie HTML/CSS oraz zachowaniu rozdziału obowiązków. Biblioteka zarządza złożonością za Ciebie dzięki kompletnemu API.
Chociaż obie biblioteki mają swoje zalety, IronPDF wyróżnia się bogatym zestawem funkcji i prostotą obsługi. Testy wydajności pokazują, że IronPDF sprawnie radzi sobie z dużymi dokumentami. Dla zespołów, które stawiają na długoterminową łatwość utrzymania, IronPDF oferuje kompletną dokumentację, profesjonalne wsparcie i obszerne przykłady kodu.
IronPDF jest bezpłatny do użytku programistycznego i zawiera bezpłatną wersję próbną umożliwiającą zapoznanie się z zaawansowanymi funkcjami. Aby dowiedzieć się więcej o przeglądaniu treści plików PDF, zapoznaj się z przewodnikiem dotyczącym wyodrębniania tekstu i obrazów. Dodatkowe przykłady można znaleźć w sekcji Przykłady kodu IronPDF HTML do PDF. Twoja aplikacja może od razu skorzystać z nowoczesnej architektury i pełnych możliwości IronPDF.
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.
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.
