PORóWNANIE

Text Control vs IronPDF: Przewodnik porównania technicznego

Zaktualizowano:

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%, wymagańą 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: Udokumentówane 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ść: udokumentówana niezawodność w różnych konfiguracjach sprzętowych, bez problemów z renderowaniem typowych dla konkretnych platform
  • Prosta integracja: nie wymaga zarządzania kontekstem ani skomplikówanych schematów inicjalizacji

Porównanie cen

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

Aspekt TX Text Control IronPDF
Licencja podstawowa 3 398 USD+ na programistę 749 USD jednorazowo za programistę
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ę 749 USD na programistę
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 aIronPDFw 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 skomplikówana 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 aIronPDFpolega na filozofii projektowania API oraz wzorcach inicjalizacji.

Podejście TextControl

TextControl wymaga jawnego zarządzania kontekstem poprzez klasę ServerTextControl. Każda operacja musi być wykonana w bloku using po wywołaniu 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);
            }
        }
    }
}
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
$vbLabelText   $csharpLabel

Ten wzorzec wymaga zrozumieniuiuiuiuia 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");
        }
    }
}
Imports IronPdf

Namespace IronPdfExample
    Class Program
        Shared Sub Main(ByVal 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
$vbLabelText   $csharpLabel

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 naIronPDFuznają to zestawienie za pomocne w zrozumieniuiuiuiuiu 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);
            }
        }
    }
}
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
$vbLabelText   $csharpLabel

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");
        }
    }
}
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
$vbLabelText   $csharpLabel

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);
            }
        }
    }
}
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>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 Class
End Namespace
$vbLabelText   $csharpLabel

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");
        }
    }
}
Imports IronPdf
Imports IronPdf.Rendering

Namespace IronPdfExample
    Class Program
        Shared Sub Main(args As String())
            Dim renderer As 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 Class
End Namespace
$vbLabelText   $csharpLabel

W przypadku bardziej złożonych projektów nagłówkówIronPDFobsł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
}
$vbLabelText   $csharpLabel

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

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")
$vbLabelText   $csharpLabel

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

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")
$vbLabelText   $csharpLabel

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

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")
$vbLabelText   $csharpLabel

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ą

Udokumentówany błąd karty graficznej Intel Iris Xe Graphics, który dotyczy procesorów Intel 11. generacji, wymaga zastosowania obejść w rejestrze systemówym w przypadku wdrożeń TextControl. Renderowanie oparte na silniku Chromium wIronPDFcał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 przezIronPDFzapewnia 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.IronPDFdziała jako samodzielny pakiet NuGet bez zewnętrznych zależności ani skomplikówanych schematów inicjalizacji.

Alternatywy dla szablonów i korespondencji seryjnej

Własny system korespondencji seryjnej TextControl wykorzystuje szablony DOCX z polami scałania.IronPDFzastę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");
Imports IronPdf

Dim data = New With {.CustomerName = "John Doe", .InvoiceNumber = "12345", .Total = "$1,500.00"}

Dim 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>"

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("invoice.pdf")
$vbLabelText   $csharpLabel

W przypadku bardziej złożonych scenariuszy tworzenia szablonówIronPDFintegruje 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.IronPDFjest 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ówIronPDFoferuje funkcje edycji dokumentów, które zwiększają jego użyteczność:

Wnioski

TX Text Control iIronPDFsł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, ocenaIronPDFmoż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.