Porównanie pomiędzy iTextSharp i IronPDF do edytowania plików PDF

iText to oficjalny następca iText i oferuje całkowicie przeprojektowaną architekturę. To potężna, rozszerzalna biblioteka odpowiednia do tworzenia, edytowania i weryfikacji plików PDF w branżach o rygorystycznych wymaganiach dotyczących zgodności, takich jak prawo, finanse i rząd. Zestaw iText obejmuje wsparcie dla PDF/A, PDF/UA, podpisów cyfrowych, redakcji i tworzenia formularzy.

Chociaż wciąż jest open source pod licencją AGPL, dostępne jest komercyjne licencjonowanie dla projektów zastrzeżonych.

Kluczowe cechy iText

• Nowoczesne API zastępujące starszą strukturę iText
• Modułowe wsparcie: HTML do PDF, PDF/A, formularze, redakcja, cyfrowe podpisy
• Wysoka wydajność dla aplikacji klasy enterprise
• Doskonałe do PDF/A, dostępności, zgodności

Instalacja (NuGet)

Aby pobrać główny pakiet iText do generowania PDF:

Install-Package itext7

Możesz także zainstalować iText przez ekran menedżera pakietów dla rozwiązań. Aby to zrobić, najpierw musisz przejść do rozwijanego menu Narzędzia, a następnie znaleźć 'NuGet Package Manager > Zarządzaj pakietami NuGet dla rozwiązania'.

Następnie po prostu wyszukaj iText i kliknij "Zainstaluj".

Przykład kodu: Utwórz dokumenty PDF z tablicy bajtów używając iText

using System.IO;
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.GeneratePdfWithIText7();
        // Save the PDF to a file
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] GeneratePdfWithIText7()
    {
        using (var ms = new MemoryStream())
        {
            var writer = new PdfWriter(ms);
            var pdf = new iText.Kernel.Pdf.PdfDocument(writer);
            var doc = new Document(pdf);

            doc.Add(new Paragraph("Hello from iText 7 for .NET!"));

            doc.Close(); // Always close the document to finalize content  
            return ms.ToArray();
        }
    }
}

using System.IO;
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.GeneratePdfWithIText7();
        // Save the PDF to a file
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] GeneratePdfWithIText7()
    {
        using (var ms = new MemoryStream())
        {
            var writer = new PdfWriter(ms);
            var pdf = new iText.Kernel.Pdf.PdfDocument(writer);
            var doc = new Document(pdf);

            doc.Add(new Paragraph("Hello from iText 7 for .NET!"));

            doc.Close(); // Always close the document to finalize content  
            return ms.ToArray();
        }
    }
}

Imports System.IO
Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim pdfGenerator As New PdfGenerator()
		Dim pdfBytes() As Byte = pdfGenerator.GeneratePdfWithIText7()
		' Save the PDF to a file
		File.WriteAllBytes("output.pdf", pdfBytes)
	End Sub
End Class

Friend Class PdfGenerator
	Public Function GeneratePdfWithIText7() As Byte()
		Using ms = New MemoryStream()
			Dim writer = New PdfWriter(ms)
			Dim pdf = New iText.Kernel.Pdf.PdfDocument(writer)
			Dim doc = New Document(pdf)

			doc.Add(New Paragraph("Hello from iText 7 for .NET!"))

			doc.Close() ' Always close the document to finalize content
			Return ms.ToArray()
		End Using
	End Function
End Class

Plik wyjściowy w formacie PDF

Wyjaśnienie

• PdfWriter zapisuje zawartość do MemoryStream.
• PdfDocument zarządza wewnętrzną strukturą PDF.
• Document jest używany do dodawania treści wysokiego poziomu (tekst, obrazy, tabele).
• Po wywołaniu doc.Close() zawartość PDF jest w pełni zapisana i gotowa do zwrócenia jako tablica bajtów.

Ten przykład pokazuje bardziej modułowe i czytelne API iText w porównaniu do iText. Jednak nadal brakuje natywnego wsparcia dla renderowania HTML/CSS, o ile nie dodasz pdfhtml, który jest licencjonowany osobno.

Zalety i wady iText

Zalety:

• Wszechstronne zarządzanie PDF\ iText zapewnia pełną kontrolę nad elementami PDF, takimi jak tabele, formularze i podpisy cyfrowe. To czyni go idealnym dla aplikacji wymagających ściśle określonych standardów PDF, takich jak PDF/A lub PDF/UA.

• Modułowe i skalowalne\ iText jest modułowy, co oznacza, że możesz zainstalować tylko konkretne moduły, które potrzebujesz (np. pdfhtml do konwersji HTML na PDF). Pozwala to na bardziej lekką implementację jeśli nie korzystasz ze wszystkich funkcji.

• Obsługuje złożone standardy PDF\ iText wspiera standardy ISO, takie jak PDF/A (archiwizacja), PDF/UA (dostępność) i PDF/X (drukowanie), co czyni go odpowiednim dla profesjonalnych i prawnych środowisk, gdzie zgodność jest kluczowa.

• Bogata dokumentacja i wsparcie\ iText ma kompleksową dokumentację i dużą społeczność. Firma oferuje również profesjonalne wsparcie, co zapewnia, że deweloperzy mogą uzyskać pomoc, gdy jest potrzebna.

• Dostępna wersja darmowa (AGPL)\ Deweloperzy mogą używać iText za darmo pod licencją AGPL, co jest idealne dla projektów open-source lub użytku osobistego.

Wady:

• Licencja AGPL dla użytku komercyjnego\ Chociaż iText oferuje darmową wersję, użytkownicy komercyjni muszą przestrzegać licencji AGPL, która wymaga ujawnienia kodu źródłowego każdego oprogramowania korzystającego z iText lub zakupu licencji komercyjnej.

• Stroma krzywa uczenia się\ API iText jest bardziej złożone i bogate w funkcje, co może skutkować stromą krzywą nauki w porównaniu do prostszych bibliotek jak IronPDF. Deweloperzy muszą zapoznać się z jego niskopoziomową strukturą dokumentów i architekturą modułową.

• Ciężar dla prostych zadań\ iText może wydawać się uciążliwy dla podstawowych zadań PDF, takich jak proste tworzenie dokumentów lub podstawowa konwersja HTML na PDF, szczególnie w porównaniu do bibliotek jak IronPDF, które upraszczają ten proces.

• Wymaga zewnętrznych modułów do HTML do PDF\ Konwersja HTML do PDF w iText jest dostępna tylko poprzez dodatkowy moduł pdfhtml, który wymaga osobnej instalacji i może nie obsługiwać nowoczesnych treści sieciowych tak płynnie, jak IronPDF.

IronPDF to rozszerzona biblioteka .NET zaprojektowana tak, aby uprościć generowanie dokumentów PDF, koncentrując się na produktywności dewelopera. Jest szczególnie skuteczna w renderowaniu treści HTML i stylizacji, co czyni ją idealną dla nowoczesnych przepływów pracy z web-to-PDF.

Kluczowe funkcje:

• Tworzenie plików PDF z tablic bajtów i praca z dokumentami PDF bez potrzeby instalacji Adobe Reader
• Bezpośrednie renderowanie HTML do PDF za pomocą pełnego silnika Chromium w celu tworzenia dokumentów PDF z treści HTML
• Działa z widokami MVC, stronami Razor i adresami URL lokalnymi/zdalnymi
• Obsługuje pliki graficzne, JavaScript, CSS i układy responsywne od razu po wyjęciu z pudełka
• Łatwa w użyciu składnia i minimalna konfiguracja
• Licencjowanie wieczyste i brak ograniczeń AGPL

IronPDF można także zainstalować za pomocą NuGet, wykonując następujące polecenie w konsoli NuGet Package Manager:

Install-Package IronPdf

Alternatywnie, możesz zainstalować go za pomocą menedżera pakietów NuGet dla ekranu Solution. Aby to zrobić, przejdź do "Narzędzia > Menedżer pakietów NuGet > Zarządzaj pakietami NuGet dla rozwiązania".

Następnie, wyszukaj IronPDF i kliknij 'Zainstaluj'.

Po instalacji, możesz rozpocząć renderowanie pełnych stron HTML do PDF w ciągu kilku sekund — bez potrzeby dodatkowych modułów. Obsługuje nowoczesny CSS, JavaScript, a nawet interaktywną zawartość webową bez dodatkowej konfiguracji.

Przykład kodu: Tworzenie dokumentów PDF z tablicy bajtów z IronPDF

using IronPdf;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.GeneratePdfWithIronPdf();
        // Save the PDF to a file
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] GeneratePdfWithIronPdf()
    {
        var renderer = new ChromePdfRenderer();
        var pdfDoc = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
        return pdfDoc.BinaryData;
    }
}

using IronPdf;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.GeneratePdfWithIronPdf();
        // Save the PDF to a file
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] GeneratePdfWithIronPdf()
    {
        var renderer = new ChromePdfRenderer();
        var pdfDoc = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
        return pdfDoc.BinaryData;
    }
}

Imports IronPdf
Imports System.IO

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim pdfGenerator As New PdfGenerator()
		Dim pdfBytes() As Byte = pdfGenerator.GeneratePdfWithIronPdf()
		' Save the PDF to a file
		File.WriteAllBytes("output.pdf", pdfBytes)
	End Sub
End Class

Friend Class PdfGenerator
	Public Function GeneratePdfWithIronPdf() As Byte()
		Dim renderer = New ChromePdfRenderer()
		Dim pdfDoc = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>")
		Return pdfDoc.BinaryData
	End Function
End Class

Plik wyjściowy w formacie PDF

Wyjaśnienie

• Oświadczenie using IronPdf importuje bibliotekę IronPDF do dostępu do wszystkich klas związanych z PDF.
• var renderer = new ChromePdfRenderer() tworzy nowy renderer HTML do PDF napędzany przez silnik Chromium.
• renderer.RenderHtmlAsPdf(...) zamienia podany ciąg HTML na dokument PDF. Możesz także przekazać ścieżki plików lub adresy URL.
• pdfDoc.BinaryData zwraca finalny PDF jako tablica bajtów, gotowy do zapisania, przesyłania strumieniowego lub przechowywania w bazie danych.

Zalety i wady IronPDF

Zalety:

• Bezproblemowe renderowanie HTML do PDF\ Renderowanie treści HTML, CSS i JavaScript bezpośrednio do PDF z pełnym formatowaniem, w tym Bootstrap i niestandardowe czcionki — brak potrzeby skomplikowanego kodu układu lub dodatkowych modułów.

• Szybki start i intuicyjne API\ Tworzenie plików PDF w pełni sformatowanych w zaledwie kilku liniach kodu, z czystą składnią i pełną zgodnością z .NET Core i .NET Framework.

• Obsługa technologii webowych\ IronPDF obsługuje JavaScript, nowoczesny CSS, SVGs i zapytania medialne — coś, z czym większość bibliotek ma problemy, jeśli nie używa bezgłowych przeglądarek, takich jak Chromium (co IronPDF robi wewnętrznie).

• Wbudowane przetwarzanie obrazów i zasobów\ Łatwo dołączaj obrazy, pliki lokalne lub nawet pobieraj zasoby z zdalnych adresów URL bez dodatkowej konfiguracji.

• Licencjowanie wieczyste i brak AGPL\ W przeciwieństwie do iText, IronPDF oferuje elastyczne licencjonowanie komercyjne bez ograniczeń wynikających z zobowiązań open-source AGPL.

• Doskonałe do widoków MVC i Razor\ Bezproblemowo konwertuje widoki .cshtml Razor w aplikacjach ASP.NET na printable PDF.

Wady:

• Użytek komercyjny wymaga licencji\ Choć dostępna jest darmowa wersja próbna, IronPDF nie jest otwartoźródłowy. Projekty z ograniczonym budżetem mogą musieć ocenić koszty licencji.

• Większy rozmiar początkowy pakietu\ Ponieważ zawiera bezgłowy silnik Chromium, pakiet NuGet jest cięższy niż niektóre alternatywy.

IronPDF

using IronPdf;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.GeneratePdfFromUrlWithIronPdf();

        // Save the PDF to a file
        File.WriteAllBytes("ironpdf-from-url.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] GeneratePdfFromUrlWithIronPdf()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.WaitForJavaScript(5000);
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

        var pdf = renderer.RenderUrlAsPdf("https://www.apple.com");
        return pdf.BinaryData;
    }
}

using IronPdf;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.GeneratePdfFromUrlWithIronPdf();

        // Save the PDF to a file
        File.WriteAllBytes("ironpdf-from-url.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] GeneratePdfFromUrlWithIronPdf()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.WaitForJavaScript(5000);
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

        var pdf = renderer.RenderUrlAsPdf("https://www.apple.com");
        return pdf.BinaryData;
    }
}

Imports IronPdf
Imports System.IO

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim pdfGenerator As New PdfGenerator()
		Dim pdfBytes() As Byte = pdfGenerator.GeneratePdfFromUrlWithIronPdf()

		' Save the PDF to a file
		File.WriteAllBytes("ironpdf-from-url.pdf", pdfBytes)
	End Sub
End Class

Friend Class PdfGenerator
	Public Function GeneratePdfFromUrlWithIronPdf() As Byte()
		Dim renderer = New ChromePdfRenderer()
		renderer.RenderingOptions.EnableJavaScript = True
		renderer.RenderingOptions.WaitForJavaScript(5000)
		renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print

		Dim pdf = renderer.RenderUrlAsPdf("https://www.apple.com")
		Return pdf.BinaryData
	End Function
End Class

Wynik w formacie PDF

IronPDF używa bezgłowego silnika Chromium do pixeli-idealnego renderowania stron internetowych z pełnym wsparciem dla JavaScript i CSS.

iText

using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using System.Net.Http;
using System.Threading.Tasks;
using iText.Html2pdf;
using System.IO;

class Program
{
    static async Task Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = await pdfGenerator.GeneratePdfFromUrlWithIText7Async();

        // Save the PDF to a file
        File.WriteAllBytes("itext7-from-url.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public async Task<byte[]> GeneratePdfFromUrlWithIText7Async()
    {
        using var httpClient = new HttpClient();
        string html = await httpClient.GetStringAsync("https://www.apple.com");

        using var stream = new MemoryStream();
        HtmlConverter.ConvertToPdf(html, stream);
        return stream.ToArray();
    }
}

using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using System.Net.Http;
using System.Threading.Tasks;
using iText.Html2pdf;
using System.IO;

class Program
{
    static async Task Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = await pdfGenerator.GeneratePdfFromUrlWithIText7Async();

        // Save the PDF to a file
        File.WriteAllBytes("itext7-from-url.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public async Task<byte[]> GeneratePdfFromUrlWithIText7Async()
    {
        using var httpClient = new HttpClient();
        string html = await httpClient.GetStringAsync("https://www.apple.com");

        using var stream = new MemoryStream();
        HtmlConverter.ConvertToPdf(html, stream);
        return stream.ToArray();
    }
}

Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Imports System.Net.Http
Imports System.Threading.Tasks
Imports iText.Html2pdf
Imports System.IO

Friend Class Program
	Shared Async Function Main(ByVal args() As String) As Task
		Dim pdfGenerator As New PdfGenerator()
		Dim pdfBytes() As Byte = Await pdfGenerator.GeneratePdfFromUrlWithIText7Async()

		' Save the PDF to a file
		File.WriteAllBytes("itext7-from-url.pdf", pdfBytes)
	End Function
End Class

Friend Class PdfGenerator
	Public Async Function GeneratePdfFromUrlWithIText7Async() As Task(Of Byte())
		Dim httpClient As New HttpClient()
		Dim html As String = Await httpClient.GetStringAsync("https://www.apple.com")

		Dim stream = New MemoryStream()
		HtmlConverter.ConvertToPdf(html, stream)
		Return stream.ToArray()
	End Function
End Class

Wynik

iText pobiera surowy HTML przy użyciu HttpClient i renderuje za pomocą HtmlConverter, jednak nie obsługuje wykonywania JavaScript (jak potwierdza oficjalna dokumentacja iText, która zaleca używanie Selenium lub innej automatyzacji przeglądarki do wstępnego przetwarzania JavaScript) i ma ograniczone stylizowanie CSS. Podczas gdy iText dodał częściowe wsparcie dla flexbox w wersji 7.1.15 (2021), wiele właściwości CSS3 pozostaje nieobsługiwanych, zwłaszcza dla złożonych nowoczesnych układów.

IronPDF

using IronPdf;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();

        // Save the PDF to a file
        File.WriteAllBytes("ironpdf-with-image.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] CreatePdfWithImage()
    {
        var pdf = ImageToPdfConverter.ImageToPdf("example.png");
        return pdf.BinaryData;
    }
}

using IronPdf;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();

        // Save the PDF to a file
        File.WriteAllBytes("ironpdf-with-image.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] CreatePdfWithImage()
    {
        var pdf = ImageToPdfConverter.ImageToPdf("example.png");
        return pdf.BinaryData;
    }
}

Imports IronPdf
Imports System.IO

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim pdfGenerator As New PdfGenerator()
		Dim pdfBytes() As Byte = pdfGenerator.CreatePdfWithImage()

		' Save the PDF to a file
		File.WriteAllBytes("ironpdf-with-image.pdf", pdfBytes)
	End Sub
End Class

Friend Class PdfGenerator
	Public Function CreatePdfWithImage() As Byte()
		Dim pdf = ImageToPdfConverter.ImageToPdf("example.png")
		Return pdf.BinaryData
	End Function
End Class

Wynik

Łatwa generacja obrazu do PDF za pomocą narzędzia ImageToPdfConverter IronPDF. Dzięki temu możesz łatwo stworzyć pliki PDF z obrazów, takich jak pliki PNG lub JPG.

iText

using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();

        // Save the PDF to a file
        File.WriteAllBytes("iText-with-image.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] CreatePdfWithImage()
    {
        using var ms = new MemoryStream();
        using var writer = new PdfWriter(ms);
        using var pdfDoc = new iText.Kernel.Pdf.PdfDocument(writer);
        var document = new Document(pdfDoc);

        var img = new Image(ImageDataFactory.Create("https://itextpdf.com/sites/default/files/2018-11/iText%207%20Product%20software%20-%20webimages_509x339px_V2_iText%207%20Core.png"));
        document.Add(img);
        document.Close();

        return ms.ToArray();
    }
}

using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();

        // Save the PDF to a file
        File.WriteAllBytes("iText-with-image.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] CreatePdfWithImage()
    {
        using var ms = new MemoryStream();
        using var writer = new PdfWriter(ms);
        using var pdfDoc = new iText.Kernel.Pdf.PdfDocument(writer);
        var document = new Document(pdfDoc);

        var img = new Image(ImageDataFactory.Create("https://itextpdf.com/sites/default/files/2018-11/iText%207%20Product%20software%20-%20webimages_509x339px_V2_iText%207%20Core.png"));
        document.Add(img);
        document.Close();

        return ms.ToArray();
    }
}

Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.IO.Image
Imports iText.Layout.Element
Imports System.IO

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim pdfGenerator As New PdfGenerator()
		Dim pdfBytes() As Byte = pdfGenerator.CreatePdfWithImage()

		' Save the PDF to a file
		File.WriteAllBytes("iText-with-image.pdf", pdfBytes)
	End Sub
End Class

Friend Class PdfGenerator
	Public Function CreatePdfWithImage() As Byte()
		Dim ms = New MemoryStream()
		Dim writer = New PdfWriter(ms)
		Dim pdfDoc = New iText.Kernel.Pdf.PdfDocument(writer)
		Dim document As New Document(pdfDoc)

		Dim img = New Image(ImageDataFactory.Create("https://itextpdf.com/sites/default/files/2018-11/iText%207%20Product%20software%20-%20webimages_509x339px_V2_iText%207%20Core.png"))
		document.Add(img)
		document.Close()

		Return ms.ToArray()
	End Function
End Class

Wynik

Ręczne tworzenie układu dokumentu i jawne wstawianie obrazów przy użyciu ImageDataFactory.

IronPDF

using IronPdf;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.CreateStyledPdf();

        // Save the PDF to a file
        File.WriteAllBytes("ironpdf-styled-html.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] CreateStyledPdf()
    {
        string html = @"
        <html>
            <head>
                <style>
                    body { 
                        background-color: #f0f0f0; 
                        margin: 20px; 
                        padding: 20px; 
                        border-radius: 5px; 
                        box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
                    }
                    h1 { 
                        color: navy;
                        font-size: 32px;   
                        text-align: center;
                       }
                    p { 
                        font-size: 16px; 
                        font-weight: bold;
                      }
                </style>
            </head>
            <body>
                <h1>Welcome to IronPDF</h1>
                <p>This is a simple PDF document generated using IronPDF.</p>
            </body>
        </html>";

        var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
        return pdf.BinaryData;
    }
}

using IronPdf;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.CreateStyledPdf();

        // Save the PDF to a file
        File.WriteAllBytes("ironpdf-styled-html.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] CreateStyledPdf()
    {
        string html = @"
        <html>
            <head>
                <style>
                    body { 
                        background-color: #f0f0f0; 
                        margin: 20px; 
                        padding: 20px; 
                        border-radius: 5px; 
                        box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
                    }
                    h1 { 
                        color: navy;
                        font-size: 32px;   
                        text-align: center;
                       }
                    p { 
                        font-size: 16px; 
                        font-weight: bold;
                      }
                </style>
            </head>
            <body>
                <h1>Welcome to IronPDF</h1>
                <p>This is a simple PDF document generated using IronPDF.</p>
            </body>
        </html>";

        var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
        return pdf.BinaryData;
    }
}

Imports IronPdf
Imports System.IO

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim pdfGenerator As New PdfGenerator()
		Dim pdfBytes() As Byte = pdfGenerator.CreateStyledPdf()

		' Save the PDF to a file
		File.WriteAllBytes("ironpdf-styled-html.pdf", pdfBytes)
	End Sub
End Class

Friend Class PdfGenerator
	Public Function CreateStyledPdf() As Byte()
		Dim html As String = "
        <html>
            <head>
                <style>
                    body { 
                        background-color: #f0f0f0; 
                        margin: 20px; 
                        padding: 20px; 
                        border-radius: 5px; 
                        box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
                    }
                    h1 { 
                        color: navy;
                        font-size: 32px;   
                        text-align: center;
                       }
                    p { 
                        font-size: 16px; 
                        font-weight: bold;
                      }
                </style>
            </head>
            <body>
                <h1>Welcome to IronPDF</h1>
                <p>This is a simple PDF document generated using IronPDF.</p>
            </body>
        </html>"

		Dim pdf = (New ChromePdfRenderer()).RenderHtmlAsPdf(html)
		Return pdf.BinaryData
	End Function
End Class

Wynik

IronPDF w pełni obsługuje CSS w znacznikach lub zewnętrzne arkusze stylów dzięki swojemu silnikowi Chromium.

iText + pdfHTML

using iText.Kernel.Pdf;
using iText.Html2pdf;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.CreateStyledPdf();

        // Save the new document to the specified file location
        File.WriteAllBytes("iText-styled-html.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] CreateStyledPdf()
    {
        string html = @"
        <html>
            <head>
                <style>
                    body { 
                        background-color: #f0f0f0; 
                        margin: 20px; 
                        padding: 20px; 
                        border-radius: 5px; 
                        box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
                    }
                    h1 { 
                        color: navy;
                        font-size: 32px;   
                        text-align: center;
                       }
                    p { 
                        font-size: 16px; 
                        font-weight: bold;
                      }
                </style>
            </head>
            <body>
                <h1>Welcome to iText 7</h1>
                <p>This is a simple PDF document generated using iText 7 and pdfHTML.</p>
            </body>
        </html>";

        using var ms = new MemoryStream();
        ConverterProperties properties = new ConverterProperties();
        HtmlConverter.ConvertToPdf(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(html)), ms, properties);
        return ms.ToArray();
    }
}

using iText.Kernel.Pdf;
using iText.Html2pdf;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var pdfGenerator = new PdfGenerator();
        byte[] pdfBytes = pdfGenerator.CreateStyledPdf();

        // Save the new document to the specified file location
        File.WriteAllBytes("iText-styled-html.pdf", pdfBytes);
    }
}

class PdfGenerator
{
    public byte[] CreateStyledPdf()
    {
        string html = @"
        <html>
            <head>
                <style>
                    body { 
                        background-color: #f0f0f0; 
                        margin: 20px; 
                        padding: 20px; 
                        border-radius: 5px; 
                        box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
                    }
                    h1 { 
                        color: navy;
                        font-size: 32px;   
                        text-align: center;
                       }
                    p { 
                        font-size: 16px; 
                        font-weight: bold;
                      }
                </style>
            </head>
            <body>
                <h1>Welcome to iText 7</h1>
                <p>This is a simple PDF document generated using iText 7 and pdfHTML.</p>
            </body>
        </html>";

        using var ms = new MemoryStream();
        ConverterProperties properties = new ConverterProperties();
        HtmlConverter.ConvertToPdf(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(html)), ms, properties);
        return ms.ToArray();
    }
}

Imports iText.Kernel.Pdf
Imports iText.Html2pdf
Imports System.IO

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim pdfGenerator As New PdfGenerator()
		Dim pdfBytes() As Byte = pdfGenerator.CreateStyledPdf()

		' Save the new document to the specified file location
		File.WriteAllBytes("iText-styled-html.pdf", pdfBytes)
	End Sub
End Class

Friend Class PdfGenerator
	Public Function CreateStyledPdf() As Byte()
		Dim html As String = "
        <html>
            <head>
                <style>
                    body { 
                        background-color: #f0f0f0; 
                        margin: 20px; 
                        padding: 20px; 
                        border-radius: 5px; 
                        box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
                    }
                    h1 { 
                        color: navy;
                        font-size: 32px;   
                        text-align: center;
                       }
                    p { 
                        font-size: 16px; 
                        font-weight: bold;
                      }
                </style>
            </head>
            <body>
                <h1>Welcome to iText 7</h1>
                <p>This is a simple PDF document generated using iText 7 and pdfHTML.</p>
            </body>
        </html>"

		Dim ms = New MemoryStream()
		Dim properties As New ConverterProperties()
		HtmlConverter.ConvertToPdf(New MemoryStream(System.Text.Encoding.UTF8.GetBytes(html)), ms, properties)
		Return ms.ToArray()
	End Function
End Class

Wynik

Wymaga instalacji płatnego dodatku pdfHTML w celu obsługi zadań konwersji HTML.