Iron Suite for .NET

10 bibliotek .NET. Jeden kompletny pakiet dokumentów.

Odkryj Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

PORÓWNANIE

Text Control vs IronPDF: Przewodnik porównania technicznego

Curtis Chau

Updated: 28 czerwca 2026

Kiedy programiści .NET oceniają biblioteki do generowania plików PDF, w dyskusjach Enterprise często pojawiają się dwa rozwiązania:TX Text Controli IronPDF. Chociaż oba rozwiązania umożliwiają generowanie plików PDF, reprezentują one zasadniczo różne filozofie architektoniczne. W niniejszym porównaniu technicznym przeanalizowano obie biblioteki, aby pomóc architektom i programistom w podejmowaniu świadomych decyzji dotyczących ich aplikacji .NET.

Zrozumienie TX Text Control

TX Text Control to kompleksowy komponent do edycji dokumentów, który kładzie nacisk na możliwości edycji plików DOCX z wbudowanymi kontrolkami interfejsu użytkownika. Generowanie plików PDF stanowi funkcję dodatkową w ramach szerszej architektury przetwarzania dokumentów. Platforma zapewnia rozbudowane funkcje edycji dokumentów, dzięki czemu nadaje się do zastosowań wymagających interfejsów do edycji tekstu sformatowanego.

Jednak ten kompleksowy charakter wymaga uwzględnienia pewnych kwestii, które zespoły programistów powinny dokładnie przeanalizować:

**Kosztowne licencje:**TX Text Controldziała na licencji komercyjnej, której cena zaczyna się od 3398 USD za programistę, z obowiązkową roczną opłatą za przedłużenie licencji w wysokości 40%, wymaganą do zachowania dostępu do aktualizacji
PDF jako funkcja dodatkowa: Podstawowa architektura stawia przetwarzanie tekstu przed generowaniem plików PDF, traktując wyjście PDF jako funkcję dodatkową
Znane problemy sprzętowe: Udokumentowane błędy renderowania w kartach graficznych Intel Iris Xe Graphics, które dotyczą procesorów Intel 11. generacji, wymagają zastosowania obejść w rejestrze.
Nadmierne zależności: Zawiera komponenty interfejsu użytkownika do edycji dokumentów, które mogą być zbędne w przypadku procesów opartych na plikach PDF
Złożony interfejs API: Wymaga wzorców zarządzania kontekstem i modeli selekcji ServerTextControl

Zrozumienie IronPDF

IronPDF przyjmuje zasadniczo inne podejście, skupiając się przede wszystkim na generowaniu plików PDF bez nakładania komponentów interfejsu użytkownika lub narzędzi do edycji plików DOCX. Biblioteka wyróżnia się oszczędnym, dostosowanym do potrzeb projektem, zoptymalizowanym specjalnie pod kątem generowania i przetwarzania plików PDF, co czyni ją wysoce wydajnym narzędziem architektury opartej na formacie PDF.

Najważniejsze cechy IronPDF to:

Architektura PDF-First: Zaprojektowana od podstaw z myślą o generowaniu plików PDF, oferująca solidne możliwości tworzenia i renderowania dokumentów
Silnik renderujący Chromium: Wykorzystuje nowoczesne standardy HTML5 i CSS3 z pełną obsługą wykonywania kodu JavaScript
Efektywność kosztowa: model jednorazowej licencji eliminuje bieżące koszty subskrypcji
Sprawdzona stabilność: udokumentowana niezawodność w różnych konfiguracjach sprzętowych, bez problemów z renderowaniem typowych dla konkretnych platform
Prosta integracja: nie wymaga zarządzania kontekstem ani skomplikowanych schematów inicjalizacji

Porównanie cen

Struktury licencyjne TextControl i IronPDF ujawniają znaczne różnice w kosztach w dłuższej perspektywie czasowej:

Aspekt	TX Text Control	IronPDF
Licencja podstawowa	3 398 USD+ na programistę	`$liteLicense` jednorazowo na programiste
Coroczne odnowienie	40% obowiązkowe	Opcjonalne wsparcie
Zespół 4-osobowy (rok 1)	~6 749 USD	~2 996 USD
Całkowity koszt w ciągu 3 lat	5750 USD+ na programistę	`$liteLicense` na programiste
Komponenty interfejsu użytkownika	W pakiecie (potencjalne obciążenie)	Tylko w formacie PDF
Środowisko uruchomieniowe serwera	Dodatkowe licencje	W zestawie

Porównanie funkcji

Poniższa tabela przedstawia różnice techniczne między TextControl a IronPDF w kluczowych aspektach:

Funkcja	TX Text Control	IronPDF
Główny cel	Edycja plików DOCX	Generowanie plików PDF
Jakość pliku PDF	Podstawowe funkcje i funkcje dodatkowe	Wysoka, podstawowa funkcjonalność
HTML do PDF	Tak (drugorzędne)	Tak (główne)
Obsługa CSS	Ograniczone	Pełny CSS3
Wykonanie kodu JavaScript	Ograniczone	Pełna wersja ES2024
URL do pliku PDF	Wymagana skomplikowana konfiguracja	Wsparcie native
Nagłówki/stopki	Złożony interfejs API	Prosty kod oparty na HTML
Korespondencja seryjna	System zastrzeżony	Szablony HTML
Zgodność z PDF/A	Tak	Tak
Ochrona hasłem	Tak	Tak
Podpisy cyfrowe	Tak	Tak
Łączenie plików PDF	Ograniczone	Obsługiwane
Podział plików PDF	Ograniczone	Obsługiwane
Znaki wodne	Złożona implementacja	Prosty HTML/CSS
Kompatybilność sprzętowa	Znane problemy z Intel Iris	Działa stabilnie na wszystkich urządzeniach
Zarządzanie kontekstem	Wymagane	Nie jest potrzebne
Wielopłatformowe	Skupione na systemie Windows	Tak

Różnice w architekturze API

Kluczowa różnica między TextControl a IronPDF polega na filozofii projektowania API oraz wzorcach inicjalizacji.

Podejście TextControl

TextControl wymaga jawnego zarzadzania kontekstem poprzez klase ServerTextControl. Kazda operacja musi nastapic w bloku using po wywolaniu Create():

// NuGet: Install-Package TXTextControl.Server
using TXTextControl;
using System.IO;

namespace TextControlExample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServerTextControl textControl = new ServerTextControl())
            {
                textControl.Create();
                
                string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
                
                textControl.Load(html, StreamType.HTMLFormat);
                textControl.Save("output.pdf", StreamType.AdobePDF);
            }
        }
    }
}

// NuGet: Install-Package TXTextControl.Server
using TXTextControl;
using System.IO;

namespace TextControlExample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServerTextControl textControl = new ServerTextControl())
            {
                textControl.Create();
                
                string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
                
                textControl.Load(html, StreamType.HTMLFormat);
                textControl.Save("output.pdf", StreamType.AdobePDF);
            }
        }
    }
}

' NuGet: Install-Package TXTextControl.Server
Imports TXTextControl
Imports System.IO

Namespace TextControlExample
    Class Program
        Shared Sub Main(ByVal args() As String)
            Using textControl As New ServerTextControl()
                textControl.Create()

                Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

                textControl.Load(html, StreamType.HTMLFormat)
                textControl.Save("output.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Class
End Namespace

' NuGet: Install-Package TXTextControl.Server
Imports TXTextControl
Imports System.IO

Namespace TextControlExample
    Class Program
        Shared Sub Main(ByVal args() As String)
            Using textControl As New ServerTextControl()
                textControl.Create()

                Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

                textControl.Load(html, StreamType.HTMLFormat)
                textControl.Save("output.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Class
End Namespace

Ten wzorzec wymaga zrozumienia klas specyficznych dla TextControl, typów strumieni oraz cyklu życia kontekstu.

Podejście IronPDF

IronPDF całkowicie eliminuje konieczność zarządzania kontekstem. Klasa ChromePdfRenderer udostępnia bezstanowe API, z którego programiści mogą korzystać od razu:

// NuGet: Install-Package IronPdf
using IronPdf;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var renderer = new ChromePdfRenderer();
            
            string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
            
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs("output.pdf");
        }
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var renderer = new ChromePdfRenderer();
            
            string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
            
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs("output.pdf");
        }
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf

Namespace IronPdfExample
    Class Program
        Shared Sub Main(args As String())
            Dim renderer = New ChromePdfRenderer()

            Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

            Dim pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs("output.pdf")
        End Sub
    End Class
End Namespace

' NuGet: Install-Package IronPdf
Imports IronPdf

Namespace IronPdfExample
    Class Program
        Shared Sub Main(args As String())
            Dim renderer = New ChromePdfRenderer()

            Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

            Dim pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs("output.pdf")
        End Sub
    End Class
End Namespace

Aby uzyskać wyczerpujące wskazówki dotyczące możliwości konwersji HTML, zapoznaj się z samouczkiem dotyczącym konwersji HTML do PDF.

Przewodnik po mapowaniu API

Zespoły rozważające przejście z TextControl na IronPDF uznają to zestawienie za pomocne w zrozumieniu równoważności pojęć:

TX Text Control	IronPDF
`ServerTextControl.Create()`	`new ChromePdfRenderer()`
`tx.Load(html, StreamType.HTMLFormat)`	`renderer.RenderHtmlAsPdf(html)`
`tx.Load(url, StreamType.HTMLFormat)`	`renderer.RenderUrlAsPdf(url)`
`tx.Save(path, StreamType.AdobePDF)`	`pdf.SaveAs(path)`
`SaveSettings.PDFAConformance`	`RenderingOptions.PdfAFormat`
`DocumentServer.MailMerge`	Szablony HTML + Razor
`DocumentTarget.HeadersAndFooters`	`HtmlHeaderFooter`
`LoadSettings`	`RenderingOptions`
`StreamType.AdobePDF`	Domyślny wynik

Łączenie dokumentów PDF

Łączenie dokumentów stanowi typowe wymaganie, w przypadku którego złożoność implementacji różni się w obu bibliotekach.

Wdrożenie TextControl

TextControl wymaga sekwencyjnego ładowania dokumentów z wyraźnymi flagami trybu dołączania:

// NuGet: Install-Package TXTextControl.Server
using TXTextControl;
using System.IO;

namespace TextControlExample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServerTextControl textControl = new ServerTextControl())
            {
                textControl.Create();
                
                byte[] pdf1 = File.ReadAllBytes("document1.pdf");
                textControl.Load(pdf1, StreamType.AdobePDF);
                
                byte[] pdf2 = File.ReadAllBytes("document2.pdf");
                textControl.Load(pdf2, StreamType.AdobePDF, LoadAppendMode.Append);
                
                textControl.Save("merged.pdf", StreamType.AdobePDF);
            }
        }
    }
}

// NuGet: Install-Package TXTextControl.Server
using TXTextControl;
using System.IO;

namespace TextControlExample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServerTextControl textControl = new ServerTextControl())
            {
                textControl.Create();
                
                byte[] pdf1 = File.ReadAllBytes("document1.pdf");
                textControl.Load(pdf1, StreamType.AdobePDF);
                
                byte[] pdf2 = File.ReadAllBytes("document2.pdf");
                textControl.Load(pdf2, StreamType.AdobePDF, LoadAppendMode.Append);
                
                textControl.Save("merged.pdf", StreamType.AdobePDF);
            }
        }
    }
}

' NuGet: Install-Package TXTextControl.Server
Imports TXTextControl
Imports System.IO

Namespace TextControlExample
    Class Program
        Shared Sub Main(ByVal args As String())
            Using textControl As New ServerTextControl()
                textControl.Create()

                Dim pdf1 As Byte() = File.ReadAllBytes("document1.pdf")
                textControl.Load(pdf1, StreamType.AdobePDF)

                Dim pdf2 As Byte() = File.ReadAllBytes("document2.pdf")
                textControl.Load(pdf2, StreamType.AdobePDF, LoadAppendMode.Append)

                textControl.Save("merged.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Class
End Namespace

' NuGet: Install-Package TXTextControl.Server
Imports TXTextControl
Imports System.IO

Namespace TextControlExample
    Class Program
        Shared Sub Main(ByVal args As String())
            Using textControl As New ServerTextControl()
                textControl.Create()

                Dim pdf1 As Byte() = File.ReadAllBytes("document1.pdf")
                textControl.Load(pdf1, StreamType.AdobePDF)

                Dim pdf2 As Byte() = File.ReadAllBytes("document2.pdf")
                textControl.Load(pdf2, StreamType.AdobePDF, LoadAppendMode.Append)

                textControl.Save("merged.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Class
End Namespace

Wdrożenie IronPDF

IronPDF udostępnia dedykowaną metodę statyczną do scałania, która akceptuje wiele dokumentów:

// NuGet: Install-Package IronPdf
using IronPdf;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var pdf1 = PdfDocument.FromFile("document1.pdf");
            var pdf2 = PdfDocument.FromFile("document2.pdf");
            
            var merged = PdfDocument.Merge(pdf1, pdf2);
            merged.SaveAs("merged.pdf");
        }
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var pdf1 = PdfDocument.FromFile("document1.pdf");
            var pdf2 = PdfDocument.FromFile("document2.pdf");
            
            var merged = PdfDocument.Merge(pdf1, pdf2);
            merged.SaveAs("merged.pdf");
        }
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf

Namespace IronPdfExample
    Class Program
        Shared Sub Main(ByVal args As String())
            Dim pdf1 = PdfDocument.FromFile("document1.pdf")
            Dim pdf2 = PdfDocument.FromFile("document2.pdf")

            Dim merged = PdfDocument.Merge(pdf1, pdf2)
            merged.SaveAs("merged.pdf")
        End Sub
    End Class
End Namespace

' NuGet: Install-Package IronPdf
Imports IronPdf

Namespace IronPdfExample
    Class Program
        Shared Sub Main(ByVal args As String())
            Dim pdf1 = PdfDocument.FromFile("document1.pdf")
            Dim pdf2 = PdfDocument.FromFile("document2.pdf")

            Dim merged = PdfDocument.Merge(pdf1, pdf2)
            merged.SaveAs("merged.pdf")
        End Sub
    End Class
End Namespace

Metoda PdfDocument.Merge przyjmuje dowolną liczbę dokumentów i zwraca nowy, połączony plik PDF bez konieczności zarządzania kontekstem lub ręcznej obsługi tablicy bajtów.

Nagłówki, stopki i numeracja stron

Dodanie nagłówków i stopek z dynamicznymi numerami stron pokazuje znaczące różnice w złożoności API.

Wdrożenie TextControl

TextControl wymaga manipulacji nagłówkami/stopkami w oparciu o sekcje z wyraźnymi deklaracjami typów:

// NuGet: Install-Package TXTextControl.Server
using TXTextControl;
using System.IO;

namespace TextControlExample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServerTextControl textControl = new ServerTextControl())
            {
                textControl.Create();
                
                string html = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>";
                textControl.Load(html, StreamType.HTMLFormat);
                
                HeaderFooter header = new HeaderFooter(HeaderFooterType.Header);
                header.Text = "Document Header";
                textControl.Sections[0].HeadersAndFooters.Add(header);
                
                HeaderFooter footer = new HeaderFooter(HeaderFooterType.Footer);
                footer.Text = "Page {page} of {numpages}";
                textControl.Sections[0].HeadersAndFooters.Add(footer);
                
                textControl.Save("output.pdf", StreamType.AdobePDF);
            }
        }
    }
}

// NuGet: Install-Package TXTextControl.Server
using TXTextControl;
using System.IO;

namespace TextControlExample
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServerTextControl textControl = new ServerTextControl())
            {
                textControl.Create();
                
                string html = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>";
                textControl.Load(html, StreamType.HTMLFormat);
                
                HeaderFooter header = new HeaderFooter(HeaderFooterType.Header);
                header.Text = "Document Header";
                textControl.Sections[0].HeadersAndFooters.Add(header);
                
                HeaderFooter footer = new HeaderFooter(HeaderFooterType.Footer);
                footer.Text = "Page {page} of {numpages}";
                textControl.Sections[0].HeadersAndFooters.Add(footer);
                
                textControl.Save("output.pdf", StreamType.AdobePDF);
            }
        }
    }
}

' NuGet: Install-Package TXTextControl.Server
Imports TXTextControl
Imports System.IO

Namespace TextControlExample
    Module Program
        Sub Main(args As String())
            Using textControl As New ServerTextControl()
                textControl.Create()

                Dim html As String = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>"
                textControl.Load(html, StreamType.HTMLFormat)

                Dim header As New HeaderFooter(HeaderFooterType.Header)
                header.Text = "Document Header"
                textControl.Sections(0).HeadersAndFooters.Add(header)

                Dim footer As New HeaderFooter(HeaderFooterType.Footer)
                footer.Text = "Page {page} of {numpages}"
                textControl.Sections(0).HeadersAndFooters.Add(footer)

                textControl.Save("output.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Module
End Namespace

' NuGet: Install-Package TXTextControl.Server
Imports TXTextControl
Imports System.IO

Namespace TextControlExample
    Module Program
        Sub Main(args As String())
            Using textControl As New ServerTextControl()
                textControl.Create()

                Dim html As String = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>"
                textControl.Load(html, StreamType.HTMLFormat)

                Dim header As New HeaderFooter(HeaderFooterType.Header)
                header.Text = "Document Header"
                textControl.Sections(0).HeadersAndFooters.Add(header)

                Dim footer As New HeaderFooter(HeaderFooterType.Footer)
                footer.Text = "Page {page} of {numpages}"
                textControl.Sections(0).HeadersAndFooters.Add(footer)

                textControl.Save("output.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Module
End Namespace

Wdrożenie IronPDF

IronPDF oferuje usprawnione metody dodawania nagłówków i stopek tekstowych:

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

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var renderer = new ChromePdfRenderer();
            
            string html = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>";
            
            var pdf = renderer.RenderHtmlAsPdf(html);
            
            pdf.AddTextHeader("Document Header");
            pdf.AddTextFooter("Page {page} of {total-pages}");
            
            pdf.SaveAs("output.pdf");
        }
    }
}

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

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var renderer = new ChromePdfRenderer();
            
            string html = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>";
            
            var pdf = renderer.RenderHtmlAsPdf(html);
            
            pdf.AddTextHeader("Document Header");
            pdf.AddTextFooter("Page {page} of {total-pages}");
            
            pdf.SaveAs("output.pdf");
        }
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Namespace IronPdfExample
    Module Program
        Sub Main(args As String())
            Dim renderer = New ChromePdfRenderer()

            Dim html As String = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>"

            Dim pdf = renderer.RenderHtmlAsPdf(html)

            pdf.AddTextHeader("Document Header")
            pdf.AddTextFooter("Page {page} of {total-pages}")

            pdf.SaveAs("output.pdf")
        End Sub
    End Module
End Namespace

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Namespace IronPdfExample
    Module Program
        Sub Main(args As String())
            Dim renderer = New ChromePdfRenderer()

            Dim html As String = "<html><body><h1>Document Content</h1><p>Main body text.</p></body></html>"

            Dim pdf = renderer.RenderHtmlAsPdf(html)

            pdf.AddTextHeader("Document Header")
            pdf.AddTextFooter("Page {page} of {total-pages}")

            pdf.SaveAs("output.pdf")
        End Sub
    End Module
End Namespace

W przypadku bardziej złożonych projektów nagłówków IronPDF obsługuje również klasę HtmlHeaderFooter, która akceptuje pełne style HTML i CSS:

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: center; font-size: 12pt;'>
            Company Report
        </div>",
    MaxHeight = 30
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: right; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    MaxHeight = 25
};

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: center; font-size: 12pt;'>
            Company Report
        </div>",
    MaxHeight = 30
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = @"
        <div style='width: 100%; text-align: right; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    MaxHeight = 25
};

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='width: 100%; text-align: center; font-size: 12pt;'>
            Company Report
        </div>",
    .MaxHeight = 30
}

renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='width: 100%; text-align: right; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    .MaxHeight = 25
}

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='width: 100%; text-align: center; font-size: 12pt;'>
            Company Report
        </div>",
    .MaxHeight = 30
}

renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "
        <div style='width: 100%; text-align: right; font-size: 10pt;'>
            Page {page} of {total-pages}
        </div>",
    .MaxHeight = 25
}

Konwersja adresów URL do formatu PDF

Konwersja aktywnych stron internetowych do formatu PDF ujawnia różnice architektoniczne w sposobie obsługi treści internetowych przez każdą z bibliotek.

Podejście TextControl

TextControl wymaga ręcznego ładowania adresów URL za pośrednictwem modułu obsługi formatu HTML, który zapewnia ograniczoną obsługę CSS i JavaScript:

using (ServerTextControl tx = new ServerTextControl())
{
    tx.Create();

    LoadSettings loadSettings = new LoadSettings();
    loadSettings.ApplicationFieldFormat = ApplicationFieldFormat.MSWord;
    tx.Load("https://example.com/invoice", StreamType.HTMLFormat, loadSettings);

    SaveSettings saveSettings = new SaveSettings();
    saveSettings.PDFAConformance = PDFAConformance.PDFa1b;
    tx.Save("output.pdf", StreamType.AdobePDF, saveSettings);
}

using (ServerTextControl tx = new ServerTextControl())
{
    tx.Create();

    LoadSettings loadSettings = new LoadSettings();
    loadSettings.ApplicationFieldFormat = ApplicationFieldFormat.MSWord;
    tx.Load("https://example.com/invoice", StreamType.HTMLFormat, loadSettings);

    SaveSettings saveSettings = new SaveSettings();
    saveSettings.PDFAConformance = PDFAConformance.PDFa1b;
    tx.Save("output.pdf", StreamType.AdobePDF, saveSettings);
}

Imports ServerTextControlNamespace

Using tx As New ServerTextControl()
    tx.Create()

    Dim loadSettings As New LoadSettings()
    loadSettings.ApplicationFieldFormat = ApplicationFieldFormat.MSWord
    tx.Load("https://example.com/invoice", StreamType.HTMLFormat, loadSettings)

    Dim saveSettings As New SaveSettings()
    saveSettings.PDFAConformance = PDFAConformance.PDFa1b
    tx.Save("output.pdf", StreamType.AdobePDF, saveSettings)
End Using

Imports ServerTextControlNamespace

Using tx As New ServerTextControl()
    tx.Create()

    Dim loadSettings As New LoadSettings()
    loadSettings.ApplicationFieldFormat = ApplicationFieldFormat.MSWord
    tx.Load("https://example.com/invoice", StreamType.HTMLFormat, loadSettings)

    Dim saveSettings As New SaveSettings()
    saveSettings.PDFAConformance = PDFAConformance.PDFa1b
    tx.Save("output.pdf", StreamType.AdobePDF, saveSettings)
End Using

Podejście IronPDF

IronPDF zapewnia natywne renderowanie adresów URL za pośrednictwem silnika Chromium, wykonując kod JavaScript i stosując wszystkie style:

var renderer = new ChromePdfRenderer();

// PDF/A compliance - simple property
renderer.RenderingOptions.PdfAFormat = PdfAVersions.PdfA1B;

var pdf = renderer.RenderUrlAsPdf("https://example.com/invoice");
pdf.SaveAs("output.pdf");

var renderer = new ChromePdfRenderer();

// PDF/A compliance - simple property
renderer.RenderingOptions.PdfAFormat = PdfAVersions.PdfA1B;

var pdf = renderer.RenderUrlAsPdf("https://example.com/invoice");
pdf.SaveAs("output.pdf");

Dim renderer = New ChromePdfRenderer()

' PDF/A compliance - simple property
renderer.RenderingOptions.PdfAFormat = PdfAVersions.PdfA1B

Dim pdf = renderer.RenderUrlAsPdf("https://example.com/invoice")
pdf.SaveAs("output.pdf")

Dim renderer = New ChromePdfRenderer()

' PDF/A compliance - simple property
renderer.RenderingOptions.PdfAFormat = PdfAVersions.PdfA1B

Dim pdf = renderer.RenderUrlAsPdf("https://example.com/invoice")
pdf.SaveAs("output.pdf")

Metoda RenderUrlAsPdf przechwytuje całą wyrenderowaną stronę, w tym treści generowane dynamicznie, co czyni ją idealną dla nowoczesnych aplikacji internetowych zbudowanych przy użyciu frameworków takich jak React, Angular lub Vue.js.

Ustawienia i konfiguracja strony

Konfiguracja wymiarów strony, marginesów i orientacji pokazuje różne podejścia do ustawień dokumentu.

Wdrożenie TextControl

TextControl wykorzystuje ustawienia stron oparte na sekcjach z wymiarami w TWIPS:

using (ServerTextControl tx = new ServerTextControl())
{
    tx.Create();
    tx.Load(html, StreamType.HTMLFormat);

    // Complex page settings through sections
    foreach (Section section in tx.Sections)
    {
        section.Format.PageSize = PageSize.A4;
        section.Format.PageMargins = new PageMargins(
            1440, 1440, 1440, 1440); // TWIPS
        section.Format.Landscape = true;
    }

    tx.Save("output.pdf", StreamType.AdobePDF);
}

using (ServerTextControl tx = new ServerTextControl())
{
    tx.Create();
    tx.Load(html, StreamType.HTMLFormat);

    // Complex page settings through sections
    foreach (Section section in tx.Sections)
    {
        section.Format.PageSize = PageSize.A4;
        section.Format.PageMargins = new PageMargins(
            1440, 1440, 1440, 1440); // TWIPS
        section.Format.Landscape = true;
    }

    tx.Save("output.pdf", StreamType.AdobePDF);
}

Imports TXTextControl

Using tx As New ServerTextControl()
    tx.Create()
    tx.Load(html, StreamType.HTMLFormat)

    ' Complex page settings through sections
    For Each section As Section In tx.Sections
        section.Format.PageSize = PageSize.A4
        section.Format.PageMargins = New PageMargins(1440, 1440, 1440, 1440) ' TWIPS
        section.Format.Landscape = True
    Next

    tx.Save("output.pdf", StreamType.AdobePDF)
End Using

Imports TXTextControl

Using tx As New ServerTextControl()
    tx.Create()
    tx.Load(html, StreamType.HTMLFormat)

    ' Complex page settings through sections
    For Each section As Section In tx.Sections
        section.Format.PageSize = PageSize.A4
        section.Format.PageMargins = New PageMargins(1440, 1440, 1440, 1440) ' TWIPS
        section.Format.Landscape = True
    Next

    tx.Save("output.pdf", StreamType.AdobePDF)
End Using

Wdrożenie IronPDF

IronPDF centralizuje ustawienia stron w opcjach RenderingOptions, wykorzystując intuicyjne pomiary w milimetrach:

var renderer = new ChromePdfRenderer();

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
renderer.RenderingOptions.MarginTop = 25;    // mm
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 25;
renderer.RenderingOptions.MarginRight = 25;

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

var renderer = new ChromePdfRenderer();

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
renderer.RenderingOptions.MarginTop = 25;    // mm
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 25;
renderer.RenderingOptions.MarginRight = 25;

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

Dim renderer = New ChromePdfRenderer()

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
renderer.RenderingOptions.MarginTop = 25 ' mm
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.MarginLeft = 25
renderer.RenderingOptions.MarginRight = 25

Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

Dim renderer = New ChromePdfRenderer()

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
renderer.RenderingOptions.MarginTop = 25 ' mm
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.MarginLeft = 25
renderer.RenderingOptions.MarginRight = 25

Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

Ochrona hasłem i bezpieczeństwo

Obie biblioteki obsługują funkcje zabezpieczeń plików PDF, ale z wykorzystaniem różnych wzorców API.

Wdrożenie TextControl

using (ServerTextControl tx = new ServerTextControl())
{
    tx.Create();
    tx.Load(html, StreamType.HTMLFormat);

    SaveSettings saveSettings = new SaveSettings();
    saveSettings.UserPassword = "user123";
    saveSettings.MasterPassword = "owner456";

    tx.Save("protected.pdf", StreamType.AdobePDF, saveSettings);
}

using (ServerTextControl tx = new ServerTextControl())
{
    tx.Create();
    tx.Load(html, StreamType.HTMLFormat);

    SaveSettings saveSettings = new SaveSettings();
    saveSettings.UserPassword = "user123";
    saveSettings.MasterPassword = "owner456";

    tx.Save("protected.pdf", StreamType.AdobePDF, saveSettings);
}

Imports ServerTextControlNamespace

Using tx As New ServerTextControl()
    tx.Create()
    tx.Load(html, StreamType.HTMLFormat)

    Dim saveSettings As New SaveSettings()
    saveSettings.UserPassword = "user123"
    saveSettings.MasterPassword = "owner456"

    tx.Save("protected.pdf", StreamType.AdobePDF, saveSettings)
End Using

Imports ServerTextControlNamespace

Using tx As New ServerTextControl()
    tx.Create()
    tx.Load(html, StreamType.HTMLFormat)

    Dim saveSettings As New SaveSettings()
    saveSettings.UserPassword = "user123"
    saveSettings.MasterPassword = "owner456"

    tx.Save("protected.pdf", StreamType.AdobePDF, saveSettings)
End Using

Wdrożenie IronPDF

IronPDF zapewnia szczegółową kontrolę bezpieczeństwa za pomocą właściwości SecuritySettings:

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.OwnerPassword = "owner456";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;

pdf.SaveAs("protected.pdf");

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);

pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.OwnerPassword = "owner456";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;

pdf.SaveAs("protected.pdf");

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)

pdf.SecuritySettings.UserPassword = "user123"
pdf.SecuritySettings.OwnerPassword = "owner456"
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights

pdf.SaveAs("protected.pdf")

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)

pdf.SecuritySettings.UserPassword = "user123"
pdf.SecuritySettings.OwnerPassword = "owner456"
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights

pdf.SaveAs("protected.pdf")

Kiedy zespoły rozważają alternatywy dla TextControl

Istnieje kilka scenariuszy, w których zespoły programistów często rozważają alternatywę dla TextControl:

Optymalizacja kosztów

Biorąc pod uwagę, że licencja TextControl kosztuje od 3398 USD na programistę i wymaga obowiązkowego przedłużenia o 40% rocznie, całkowity koszt posiadania w ciągu trzech lat wynosi ponad 5750 USD na programistę. Zespoły zajmujące się głównie generowaniem plików PDF często mają trudności z uzasadnieniem tej ceny, gdy istnieją alternatywne rozwiązania o znacznie niższych kosztach.

Kwestie związane z kompatybilnością sprzętową

Udokumentowany błąd karty graficznej Intel Iris Xe Graphics, który dotyczy procesorów Intel 11. generacji, wymaga zastosowania obejść w rejestrze systemowym w przypadku wdrożeń TextControl. Renderowanie oparte na silniku Chromium w IronPDF całkowicie eliminuje te problemy związane z renderowaniem specyficzne dla danego sprzętu.

Wymagania dotyczące formatu PDF

Gdy głównym zastosowaniem jest generowanie plików PDF, a nie edycja dokumentów, architektura edytora tekstu TextControl wprowadza niepotrzebną złożoność. Aplikacje, które nie wymagają możliwości edycji plików DOCX ani osadzonych elementów interfejsu użytkownika, mogą skorzystać z ukierunkowanego, zorientowanego na PDF projektu IronPDF.

Integracja nowoczesnych technologii internetowych

Ograniczona obsługa CSS i JavaScript przez TextControl stwarza wyzwania dla aplikacji korzystających z nowoczesnych frameworków frontendowych. Pełna obsługa HTML5, CSS3 i JavaScript ES2024 przez IronPDF zapewnia dokładne renderowanie nowoczesnych treści internetowych.

Uproszczone wdrażanie

Zarządzanie kontekstem ServerTextControl firmy TextControl oraz zależności komponentów interfejsu użytkownika zwiększają złożoność wdrożenia.IronPDF działa jako samodzielny pakiet NuGet bez zewnętrznych zależności ani skomplikowanych schematów inicjalizacji.

Alternatywy dla szablonów i korespondencji seryjnej

Własny system korespondencji seryjnej TextControl wykorzystuje szablony DOCX z polami scałania.IronPDF zastępuje to standardowymi metodami szablonów HTML:

// Use standard C# string interpolation
var data = new { CustomerName = "John Doe", InvoiceNumber = "12345", Total = "$1,500.00" };

var html = $@"
<html>
<head>
    <style>
        body {{font-family: Arial; padding: 40px;}}
        h1 {{color: #333;}}
        .total {{font-size: 24px; color: green;}}
    </style>
</head>
<body>
    <h1>Invoice #{data.InvoiceNumber}</h1>
    <p>Customer: {data.CustomerName}</p>
    <p class='total'>Total: {data.Total}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("invoice.pdf");

// Use standard C# string interpolation
var data = new { CustomerName = "John Doe", InvoiceNumber = "12345", Total = "$1,500.00" };

var html = $@"
<html>
<head>
    <style>
        body {{font-family: Arial; padding: 40px;}}
        h1 {{color: #333;}}
        .total {{font-size: 24px; color: green;}}
    </style>
</head>
<body>
    <h1>Invoice #{data.InvoiceNumber}</h1>
    <p>Customer: {data.CustomerName}</p>
    <p class='total'>Total: {data.Total}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("invoice.pdf");

W przypadku bardziej złożonych scenariuszy tworzenia szablonów IronPDF integruje się z silnikami Razor i innymi frameworkami do tworzenia szablonów. Szczegółowe wzorce implementacji można znaleźć w przewodniku po integracji szablonów Razor.

Zgodność z platformą .NET i gotowość na przyszłość

Obie biblioteki obsługują aktualne implementacje .NET.IronPDF jest aktywnie rozwijany i regularnie aktualizowany, co zapewnia kompatybilność z .NET 8, .NET 9 oraz przyszłymi wersjami, w tym .NET 10, którego premiera przewidziana jest na 2026 rok. Obsługa async/await w całym API biblioteki jest zgodna z nowoczesnymi praktykami programistycznymi w języku C#, w tym z funkcjami dostępnymi w C# 13 i przewidywanymi możliwościami C# 14.

Dodatkowe możliwości plików PDF

Oprócz generowania dokumentów IronPDF oferuje funkcje edycji dokumentów, które zwiększają jego użyteczność:

Łączenie plików PDF: Łączenie wielu dokumentów w pojedyncze pliki
Dzielenie dokumentów: Wyodrębnianie zakresów stron do oddzielnych plików PDF
Podpisy cyfrowe: stosowanie podpisów kryptograficznych w celu potwierdzenia autentyczności dokumentów
Znak wodny: Dodawanie tekstowych lub graficznych znaków wodnych za pomocą HTML/CSS
Zgodność z PDF/A: Generowanie dokumentów zgodnych ze standardami archiwizacji
Wypełnianie formularzy: programowe wypełnianie pól formularzy PDF

Wnioski

TX Text Control i IronPDFsłużą różnym głównym celom, mimo że oba generują pliki PDF. TextControl wyróżnia się jako wszechstronny edytor dokumentów z obsługą plików DOCX i wbudowanymi kontrolkami interfejsu użytkownika — idealny do aplikacji wymagających interfejsów do edycji tekstu sformatowanego oraz możliwości eksportu dokumentów.

IronPDF koncentruje się w szczególności na generowaniu plików PDF z HTML i treści internetowych, zapewniając usprawnione rozwiązanie dla programistów, którzy muszą konwertować HTML, adresy URL lub treści generowane dynamicznie do formatu PDF bez konieczności korzystania z pełnej infrastruktury do edycji dokumentów. Renderowanie oparte na silniku Chromium zapewnia idealną zgodność wyświetlania z przeglądarką, a konstrukcja API stawia na prostotę i integrację ze standardowymi procesami tworzenia stron internetowych.

Wybór między nimi zależy od wymagań projektu: kompleksowa edycja dokumentów z eksportem do formatu PDF przemawia na korzyść TextControl, natomiast proste generowanie plików PDF na podstawie treści internetowych odpowiada mocnym stronom IronPDF. Dla zespołów, które obecnie używają TextControl głównie do generowania plików PDF, ocena IronPDF może ujawnić możliwości znacznej redukcji kosztów i uproszczenia wdrożenia bez utraty jakości plików PDF.

Aby uzyskać dodatkowe wskazówki dotyczące wdrażania, zapoznaj się z dokumentacją IronPDF oraz samouczkami obejmującymi konkretne przypadki użycia i zaawansowane funkcje.

Zwróć uwagę: Text Control jest zarejestrowanym znakiem towarowym swojego właściciela. Ta witryna nie jest powiązana z, ani nie jest wspierana lub sponsorowana przez Text Control. Wszystkie nazwy produktów, logo i marki są własnością ich odpowiednich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.