Iron Suite for .NET

10 .NET libraries. One complete document suite.

Explore Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

COMPARISON

Text Control vs IronPDF: Technical Comparison Guide

Curtis Chau

Updated: August 1, 2026

When .NET developers evaluate PDF generation libraries, two solutions frequently emerge in enterprise discussions: TX Text Control and IronPDF. While both can produce PDF output, they represent fundamentally different architectural philosophies. This technical comparison examines both libraries to help architects and developers make informed decisions for their .NET applications.

Understanding TX Text Control

TX Text Control is a comprehensive document editor component that emphasizes DOCX editing capabilities with embedded UI controls. PDF generation exists as a secondary feature within its broader document processing architecture. The platform provides extensive document editing functionality, making it suitable for applications requiring rich text editing interfaces.

However, this comprehensive nature introduces considerations that development teams should evaluate carefully:

Expensive Licensing: TX Text Control operates on a commercial license starting at $3,398+ per developer, with mandatory 40% annual renewals required to maintain access to updates
PDF as Secondary Feature: The core architecture prioritizes word processing over PDF generation, treating PDF output as an add-on capability
Known Hardware Issues: Documented Intel Iris Xe Graphics rendering bugs affecting 11th generation Intel processors require registry workarounds
Bloated Dependencies: Includes document editing UI components that may be unnecessary for PDF-focused workflows
Complex API: Requires ServerTextControl context management and selection model patterns

Understanding IronPDF

IronPDF takes a fundamentally different approach by focusing primarily on PDF generation without layering UI components or DOCX editing tools. The library stands out for its lean, tailored design specifically optimized for PDF generation and manipulation, making it highly efficient as a PDF-first architecture tool.

Key characteristics of IronPDF include:

PDF-First Architecture: Designed from the ground up for PDF generation, offering robust document creation and rendering capabilities
Chromium Rendering Engine: Leverages modern HTML5 and CSS3 standards with full JavaScript execution support
Cost Efficiency: One-time licensing model eliminates ongoing subscription costs
Proven Stability: Documented reliability across various hardware configurations, avoiding platform-specific rendering issues
Simple Integration: No context management or complex initialization patterns required

Pricing Comparison

The licensing structures between TextControl and IronPDF reveal significant cost differences over time:

Aspect	TX Text Control	IronPDF
Base License	$3,398+ per developer	`$liteLicense` one-time per developer
Annual Renewal	40% mandatory	Optional support
Team of 4 (Year 1)	~$6,749	~$2,996
Total 3-Year Cost	$5,750+ per developer	`$liteLicense` per developer
UI Components	Bundled (potential bloat)	PDF-focused only
Server Runtime	Additional licensing	Included

Feature Comparison

The following table highlights the technical differences between TextControl and IronPDF across key dimensions:

Feature	TX Text Control	IronPDF
Primary Focus	DOCX editing	PDF generation
PDF Quality	Basic, add-on feature	High, core functionality
HTML to PDF	Yes (secondary)	Yes (primary)
CSS Support	Limited	Full CSS3
JavaScript Execution	Limited	Full ES2024
URL to PDF	Complex setup required	Native support
Headers/Footers	Complex API	Simple HTML-based
Mail Merge	Proprietary system	HTML templates
PDF/A Compliance	Yes	Yes
Password Protection	Yes	Yes
Digital Signatures	Yes	Yes
Merge PDFs	Limited	Supported
Split PDFs	Limited	Supported
Watermarks	Complex implementation	Simple HTML/CSS
Hardware Compatibility	Known Intel Iris issues	Stable across all devices
Context Management	Required	Not needed
Cross-Platform	Windows-focused	Yes

API Architecture Differences

A critical distinction between TextControl and IronPDF lies in their API design philosophies and initialization patterns.

TextControl Approach

TextControl requires explicit context management through the ServerTextControl class. Every operation must occur within a using block after calling 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

This pattern requires understanding TextControl-specific classes, stream types, and the context lifecycle.

IronPDF Approach

IronPDF eliminates context management entirely. The ChromePdfRenderer class provides a stateless API that developers can use immediately:

// 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

For comprehensive guidance on HTML conversion capabilities, see the HTML to PDF tutorial.

API Mapping Reference

Teams evaluating a transition from TextControl to IronPDF will find this mapping helpful for understanding concept equivalences:

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`	HTML templates + Razor
`DocumentTarget.HeadersAndFooters`	`HtmlHeaderFooter`
`LoadSettings`	`RenderingOptions`
`StreamType.AdobePDF`	Default output

Merging PDF Documents

Document merging represents a common requirement where implementation complexity differs between the two libraries.

TextControl Implementation

TextControl requires loading documents sequentially with explicit append mode flags:

// 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

IronPDF Implementation

IronPDF provides a dedicated static method for merging that accepts multiple documents:

// 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

The PdfDocument.Merge method accepts any number of documents and returns a new combined PDF without requiring context management or manual byte array handling.

Headers, Footers, and Page Numbering

Adding headers and footers with dynamic page numbers demonstrates significant API complexity differences.

TextControl Implementation

TextControl requires section-based header/footer manipulation with explicit type declarations:

// 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

IronPDF Implementation

IronPDF offers streamlined methods for adding text-based headers and footers:

// 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

For more complex header designs, IronPDF also supports the HtmlHeaderFooter class that accepts full HTML and CSS styling:

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
}

URL to PDF Conversion

Converting live web pages to PDF reveals architectural differences in how each library handles web content.

TextControl Approach

TextControl requires manual URL loading through its HTML format handler, which provides limited CSS and JavaScript support:

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

IronPDF Approach

IronPDF provides native URL rendering through its Chromium engine, executing JavaScript and applying all styles:

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

The RenderUrlAsPdf method captures the complete rendered page including dynamically generated content, making it ideal for modern web applications built with frameworks like React, Angular, or Vue.js.

Page Settings and Configuration

Configuring page dimensions, margins, and orientation shows different approaches to document settings.

TextControl Implementation

TextControl uses section-based page settings with measurements in 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

IronPDF Implementation

IronPDF centralizes page settings in the RenderingOptions with intuitive millimeter-based measurements:

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

Password Protection and Security

Both libraries support PDF security features, but with different API patterns.

TextControl Implementation

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

IronPDF Implementation

IronPDF provides granular security control through the SecuritySettings property:

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

When Teams Consider Alternatives to TextControl

Several scenarios commonly prompt development teams to evaluate alternatives to TextControl:

Cost Optimization

With TextControl licensing starting at $3,398+ per developer and mandatory 40% annual renewals, the three-year total cost of ownership reaches $5,750+ per developer. Teams focused primarily on PDF generation often find this pricing difficult to justify when alternatives exist at significantly lower cost points.

Hardware Compatibility Concerns

The documented Intel Iris Xe Graphics bug affecting 11th generation Intel processors requires registry workarounds for TextControl deployments. IronPDF's Chromium-based rendering eliminates these hardware-specific rendering issues entirely.

PDF-First Requirements

When PDF generation is the primary use case rather than document editing, TextControl's word processor architecture introduces unnecessary complexity. Applications that don't require DOCX editing capabilities or embedded UI controls benefit from IronPDF's focused, PDF-first design.

Modern Web Technology Integration

TextControl's limited CSS and JavaScript support creates challenges for applications using contemporary frontend frameworks. IronPDF's full HTML5, CSS3, and ES2024 JavaScript support ensures accurate rendering of modern web content.

Simplified Deployment

TextControl's ServerTextControl context management and UI component dependencies increase deployment complexity. IronPDF operates as a self-contained NuGet package without external dependencies or complex initialization patterns.

Template and Mail Merge Alternatives

TextControl's proprietary mail merge system uses DOCX templates with merge fields. IronPDF replaces this with standard HTML templating approaches:

// 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")

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

For more complex templating scenarios, IronPDF integrates with Razor engines and other templating frameworks. See the Razor template integration guide for detailed implementation patterns.

.NET Compatibility and Future Readiness

Both libraries support current .NET implementations. IronPDF maintains active development with regular updates, ensuring compatibility with .NET 8, .NET 9, and future releases including .NET 10 expected in 2026. The library's async/await support throughout its API aligns with modern C# development practices, including features available in C# 13 and anticipated C# 14 capabilities.

Additional PDF Capabilities

Beyond generation, IronPDF provides document manipulation features that extend its utility:

Merging PDFs: Combine multiple documents into single files
Splitting Documents: Extract page ranges into separate PDFs
Digital Signatures: Apply cryptographic signatures for document authenticity
Watermarking: Add text or image watermarks via HTML/CSS
PDF/A Compliance: Generate archival-standard documents
Form Filling: Programmatically populate PDF form fields

Conclusion

TX Text Control and IronPDF serve different primary purposes despite both producing PDF output. TextControl excels as a comprehensive document editor with DOCX manipulation and embedded UI controls - ideal for applications requiring rich text editing interfaces alongside document export capabilities.

IronPDF focuses specifically on PDF generation from HTML and web content, providing a streamlined solution for developers who need to convert HTML, URLs, or dynamically generated content to PDF without the overhead of a complete document editing infrastructure. Its Chromium-based rendering ensures pixel-perfect output matching browser display, while its API design prioritizes simplicity and integration with standard web development workflows.

The choice between them depends on project requirements: comprehensive document editing with PDF export favors TextControl, while straightforward PDF generation from web content aligns with IronPDF's strengths. For teams currently using TextControl primarily for PDF generation, evaluating IronPDF may reveal opportunities for significant cost reduction and simplified deployment without sacrificing PDF quality.

For additional implementation guidance, explore the IronPDF documentation and tutorials covering specific use cases and advanced features.

Please note: Text Control is a registered trademark of its respective owner. This site is not affiliated with, endorsed by, or sponsored by Text Control. All product names, logos, and brands are property of their respective owners. Comparisons are for informational purposes only and reflect publicly available information at the time of writing.