Nie znalazłeś tego, czego szukałeś?
Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Przewodniki migracji
  4. migracja z TextControl do IronPDF
PRZEWODNIKI MIGRACJI

Jak przeprowadzić migrację z TextControl do IronPDF w języku C#

Curtis Chau
Curtis Chau
Zaktualizowano:

TX Text Control ugruntował swoją pozycję jako kompleksowy komponent do edycji dokumentów w ekosystemie .NET, oferujący solidne możliwości edycji plików DOCX z wbudowanymi kontrolkami interfejsu użytkownika. Jednak dla zespołów programistycznych, których głównym wymaganiem jest generowanie plików PDF, a nie pełna edycja dokumentów, architektura TextControl wiąże się ze znacznymi obciążeniami w zakresie kosztów licencji, złożoności i zależności środowiskowych.

Niniejszy przewodnik zawiera kompletną ścieżkę migracji z TextControl do IronPDF, wraz z instrukcjami krok po kroku, porównaniami kodu i praktycznymi przykładami dla profesjonalnych programistów .NET rozważających tę zmianę.

Dlaczego warto przejść z TextControl

Decyzja o migracji z TextControl zazwyczaj opiera się na dopasowaniu narzędzi do rzeczywistych wymagań.TX Text Controlto przede wszystkim edytor dokumentów, dla którego generowanie plików PDF jest funkcją dodatkową. Główne powody, dla których zespoły programistów rozważają migrację, to:

Droga Licencja: Pojedyncza licencja deweloperaTX Text Control .NET Serverkosztuje $4,198 wieczysta z jednorocznymi aktualizacjami/wsparciem; Licencja na czterech deweloperów kosztuje $8,398 wieczysta + 1 rok (zgodnie z cenami na textcontrol.com). Odnawiania subskrypcji rocznych wynoszą około 40% ceny katalogowej (około $1,698 rocznie na dewelopera), a okres odnawiania zamyka się 30 dni po wygaśnięciu. Wdrożenie produkcyjne wymaga także oddzielnych licencji na czas działania serwera.

PDF jako Druga Ścieżka: Główna architektura to silnik przetwarzania tekstu (najpierw DOCX/RTF), a PDF jako ścieżka eksportu, a nie główna powierzchnia.

Dołączona Powierzchnia Edytora:TX Text Controlzawiera komponenty UI do edycji DOCX, które mogą być niepotrzebne, gdy wymaganie to czysto serwerowe generowanie PDF.

Architektura Procesora Tekstu: Import HTML trafia do potoku przetwarzania tekstu, a nie Chromium, więc wierność HTML5/CSS3 jest zazwyczaj słabsza niż w bibliotece PDF opartej na silniku przeglądarki.

Powiązanie STA w ASP.NET: ServerTextControl sprowadza się do komponentu w stylu STA COM i jest najpewniejszy na wątkach kompatybilnych z STA, co komplikuje asynchroniczne/MT zarządzanie hostingiem we współczesnych stosach ASP.NET Core.

Rozbudowane API: Zarządzanie kontekstem ServerTextControl plus oddzielne StringStreamType / BinaryStreamType / StreamType wyliczenia oraz model dokumentu oparty na wyborze dodają dodatkowe obciążenie dla prostych zadań generowania PDF.

Porównanie kosztów

Aspekt TX Text Control .NET Server IronPDF
Pojedynczy programista $4,198 wieczysta + 1 rok wsparcia Jednorazowa licencja na dewelopera
Zespół 4 $8,398 wieczysta + 1 rok wsparcia Niższy koszt na osobę
Coroczne odnowienie Około 40% ceny katalogowej (~$1,698/dewelopera/rok) Opcjonalne wsparcie
Czas działania serwera Wymagana oddzielna licencja na czas działania do produkcji Nie jest wymagane
Komponenty interfejsu użytkownika Zintegrowana powierzchnia edytora DOCX Skupione na PDF

IronPDF a TextControl: porównanie funkcji

Zrozumienie różnic architektonicznych pomaga decydentom technicznym w ocenie inwestycji w migrację:

Funkcja TX Text Control IronPDF
Główny cel Przetwarzanie tekstu DOCX / word-processing Generowanie plików PDF
Koszt licencji (pojedynczy deweloper) $4,198 wieczysta + 1 rok; Około 40% / rok odnawiania Jednorazowa licencja na dewelopera
Generowanie plików PDF Ścieżka eksportu na silniku przetwarzania tekstu Funkcjonalność podstawowa
Licencja na czas działania serwera Wymagane do produkcji Nie jest wymagane
Wątkowanie Preferencja STA w ASP.NET Brak wymagania STA
Renderowanie HTML/CSS Import HTML przez potok przetwarzania tekstu Chromium HTML5/CSS3
HTML do PDF Tak (drugorzędne) Tak (główne)
Obsługa CSS Ograniczone Pełny CSS3
JavaScript Ograniczone Pełna wersja ES2024
URL do pliku PDF Złożona konfiguracja Język ojczysty
Nagłówki/stopki Złożony interfejs API Prosty HTML
Korespondencja seryjna Zastrzeżone Szablony HTML
PDF/A Tak Tak
Ochrona hasłem Tak Tak
Podpisy cyfrowe Tak Tak
Łączenie plików PDF Ograniczone Tak
Podział plików PDF Ograniczone Tak
Zarządzanie kontekstem Wymagane Nie jest potrzebne
Wielopłatformowe Skupione na systemie Windows Windows / Linux / macOS / Docker

Szybki start: Migracja z TextControl do IronPDF

Migrację można rozpocząć natychmiast, wykonując te podstawowe kroki.

Krok 1: Zastąp pakiety NuGet

Bezserwerowy runtimeTX Text Controlnie jest dystrybuowany jako pojedynczy publiczny pakiet NuGet — publiczny pakiet to TXTextControl.Web (kompan edytora), a faktyczny runtime ServerTextControl jest dostarczany przez licencjonowany instalator Windows/MSI lub prywatny kanał NuGet dostawcy. Usunięcie zazwyczaj oznacza odinstalowanie tych pakietów dostarczonych przez instalator plus TXTextControl.Web oraz odinstalowanie MSI.

# RemoveTX Text Controlpackages (names depend on which were installed
# from the licensed installer / private feed / public NuGet)
dotnet remove package TXTextControl.Web

# Then install IronPDF(single self-contained package)
dotnet add package IronPdf
# RemoveTX Text Controlpackages (names depend on which were installed
# from the licensed installer / private feed / public NuGet)
dotnet remove package TXTextControl.Web

# Then install IronPDF(single self-contained package)
dotnet add package IronPdf
SHELL

Krok 2: Aktualizacja przestrzeni nazw

Zastąp przestrzenie nazw TextControl przestrzenią nazw IronPDF:

// Before (TextControl)
using TXTextControl;
using TXTextControl.DocumentServer;

// After (IronPDF)
using IronPdf;
// Before (TextControl)
using TXTextControl;
using TXTextControl.DocumentServer;

// After (IronPDF)
using IronPdf;
Imports TXTextControl
Imports TXTextControl.DocumentServer

' After (IronPDF)
Imports IronPdf
$vbLabelText   $csharpLabel

Krok 3: Inicjalizacja licencji

Dodaj inicjalizację licencji podczas uruchamiania aplikacji:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Przykłady migracji kodu

Konwersja HTML do PDF

Najczęstszy przypadek użycia ilustruje różnicę architektoniczną między tymi bibliotekami .NET do obsługi plików PDF.

Podejście TextControl:

// 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, StringStreamType.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, StringStreamType.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, StringStreamType.HTMLFormat)
                textControl.Save("output.pdf", StreamType.AdobePDF)
            End Using
        End Sub
    End Class
End Namespace
$vbLabelText   $csharpLabel

Podejście IronPDF:

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

Wersja TextControl wymaga utworzenia instancji ServerTextControl, wywołania Create() w celu zainicjowania kontekstu, załadowania HTML z StreamType.HTMLFormat i zapisania za pomocą StreamType.AdobePDF. Blok using jest obowiązkowy dla właściwego zwalniania zasobów.

IronPDF całkowicie eliminuje konieczność zarządzania kontekstem. ChromePdfRenderer nie wymaga żadnej ceremonii inicjalizacyjnej — utwórz, renderuj HTML i zapisz. To uproszczenie architektury zmniejsza obciążenie poznawcze i ogranicza potencjalne błędy w zarządzaniu zasobami.

W przypadku zaawansowanych scenariuszy konwersji HTML do PDF zapoznaj się z przewodnikiem po konwersji HTML do PDF.

Łączenie wielu plików PDF

Łączenie plików PDF ujawnia kolejną istotną różnicę w złożoności między tymi bibliotekami.

Podejście TextControl:

// 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, BinaryStreamType.AdobePDF);

                byte[] pdf2 = File.ReadAllBytes("document2.pdf");
                textControl.Append(pdf2, BinaryStreamType.AdobePDF, AppendSettings.StartWithNewSection);

                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, BinaryStreamType.AdobePDF);

                byte[] pdf2 = File.ReadAllBytes("document2.pdf");
                textControl.Append(pdf2, BinaryStreamType.AdobePDF, AppendSettings.StartWithNewSection);

                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, BinaryStreamType.AdobePDF)

                Dim pdf2 As Byte() = File.ReadAllBytes("document2.pdf")
                textControl.Append(pdf2, BinaryStreamType.AdobePDF, AppendSettings.StartWithNewSection)

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

Podejście IronPDF:

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

TextControl wymaga wczytywania plików do tablic bajtów, zarządzania kontekstem ServerTextControl i wywoływania Append za pomocą BinaryStreamType.AdobePDF oraz AppendSettings.StartWithNewSection w celu połączenia dokumentów. Metoda PdfDocument.Merge()IronPDF obsługuje wszystko jednym, wyraźnym wywołaniem.

Aby uzyskać informacje na temat zaawansowanych scenariuszy łączenia, w tym selektywnego wyodrębniania stron, zapoznaj się z przewodnikiem dotyczącym łączenia i dzielenia plików PDF.

Dodawanie nagłówków i stopek

Nagłówki i stopki z dynamicznymi numerami stron pokazują różnicę w złożoności API.

Podejście TextControl:

// 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, StringStreamType.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, StringStreamType.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, StringStreamType.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

Podejście IronPDF:

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

TextControl wymaga utworzenia obiektów HeaderFooter ze specyficznymi wyliczeniami HeaderFooterType, uzyskania dostępu do sekcji dokumentu poprzez textControl.Sections[0] i dodania do kolekcji HeadersAndFooters.IronPDF oferuje bezpośrednie metody AddTextHeader i AddTextFooter (poprzez TextHeaderFooter) z prostą składnią zastępczą.

Dla nagłówków opartych na HTML z pełną kontrolą stylizacji,IronPDF również wspiera HtmlHeaderFooter:

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

Więcej informacji na temat opcji nagłówków i stopek można znaleźć w dokumentacji dotyczącej nagłówków i stopek.

Odnośnik do dokumentacji API TextControl dla IronPDF

To mapowanie przyspiesza migrację, pokazując bezpośrednie odpowiedniki API:

TX Text Control IronPDF
ServerTextControl.Create() new ChromePdfRenderer()
tx.Load(html, StringStreamType.HTMLFormat) renderer.RenderHtmlAsPdf(html)
tx.Load(bytes, BinaryStreamType.AdobePDF) PdfDocument.FromFile(...) / FromBinaryData(...)
tx.Save(path, StreamType.AdobePDF) pdf.SaveAs(path)
tx.Append(bytes, BinaryStreamType.AdobePDF, AppendSettings.StartWithNewSection) PdfDocument.Merge(a, b)
SaveSettings.PDFAConformance RenderingOptions.PdfAFormat
DocumentServer.MailMerge Szablony HTML + Razor
HeaderFooter + Sections[i].HeadersAndFooters HtmlHeaderFooter / TextHeaderFooter
LoadSettings RenderingOptions
StreamType.AdobePDF Domyślny wynik

Typowe problemy związane z migracją i ich rozwiązania

Problem 1: Kontekst ServerTextControl

TextControl wymaga Create() i bloku using dla każdej operacji.

Rozwiązanie:IronPDF nie posiada funkcji zarządzania kontekstem:

// Just create and use
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
// Just create and use
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
' Just create and use
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Problem 2: Konwersje typów strumieni

TextControl żongluje trzema różnymi wyliczeniami — StringStreamType dla przeciążeń string, BinaryStreamType dla przeciążeń byte[] i StreamType dla Save ścieżki pliku — w celu ładowania różnych formatów i eksportu do PDF.

Rozwiązanie:IronPDF renderuje HTML bezpośrednio, bez pośredniej konwersji formatów:

// No format conversion needed
var pdf = renderer.RenderHtmlAsPdf(html);
// No format conversion needed
var pdf = renderer.RenderHtmlAsPdf(html);
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Problem 3: Szablony DOCX

TextControl używa plików DOCX jako szablonów do korespondencji seryjnej.

Rozwiązanie: Konwersja do szablonów HTML z wykorzystaniem interpolacji ciągów znaków w języku C# lub Razor:

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");
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 {Key .CustomerName = "John Doe", Key .InvoiceNumber = "12345", Key .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

Problem 4: Preferencja STA w ASP.NET

TextControl ServerTextControl historycznie odnosi się do modelu składnika typu STA COM i jest najpewniejszy, gdy jest hostowany na wątkach kompatybilnych z STA (np. [ASPCOMPAT] w klasycznych Web Forms lub obudowywanie wywołań na dedykowanym wątku/kolejce STA w ASP.NET Core). Swobodne łączenie tego z wątkami pracującymi w środowisku MTA może powodować sporadyczne błędy powiązania wątków przy dużym obciążeniu.

Rozwiązanie:IronPDF nie ma wymagań STA i działa niezmodyfikowany na wątkach pracujących w środowisku MTA, w asynchronicznych kontrolerach i w kontenerach Linux w ramach .NET 6/7/8/9.

Lista kontrolna migracji TextControl

Zadania przed migracją

Przeprowadź audyt kodu źródłowego, aby zidentyfikować wszystkie przypadki użycia TextControl:

grep -r "using TXTextControl" --include="*.cs" .
grep -r "ServerTextControl\|Load\|Save" --include="*.cs" .
grep -r "using TXTextControl" --include="*.cs" .
grep -r "ServerTextControl\|Load\|Save" --include="*.cs" .
SHELL

Szablony korespondencji seryjnej do konwersji na HTML. Uwaga na wymagania dotyczące nagłówka/stopki przy implementacji z HtmlHeaderFooter. Należy zidentyfikować wszelkie funkcje edycji plików DOCX, które mogą wymagać alternatywnych rozwiązań.

Zadania związane z aktualizacją kodu

  1. Usuń pakiety NuGet TX Text Control
  2. Zainstaluj pakiet NuGet IronPDF
  3. Usunąć zarządzanie kontekstem ServerTextControl (koniec z wywołaniami Create())
  4. Konwertować załadunki StringStreamType.HTMLFormat do RenderHtmlAsPdf
  5. Konwersja korespondencji seryjnej do szablonów HTML za pomocą interpolacji ciągów znaków lub Razor
  6. Zaktualizować nagłówki/stopki do użycia HtmlHeaderFooter lub AddTextFooter
  7. Uprościć ustawienia strony używając RenderingOptions
  8. Dodaj inicjalizację licencji podczas uruchamiania

Testy po migracji

Po migracji należy zweryfikować następujące aspekty:

  • Sprawdź, czy wszystkie szablony dokumentów wyświetlają się poprawnie
  • W razie potrzeby sprawdź zgodność z formatem PDF/A
  • Przetestuj funkcję ochrony hasłem
  • Sprawdź, czy nagłówki/stopki pojawiają się na wszystkich stronach
  • Zweryfikuj hosting ASP.NET Core na wątkach pracujących w środowisku MTA i kontenerach Linux —IronPDF nie ma wymagań dotyczących powiązania STA

Kluczowe korzyści z migracji do IronPDF

Przejście z TextControl na IronPDF zapewnia szereg korzyści dla zespołów zajmujących się generowaniem plików PDF:

Architektura PDF-First:IronPDF jest specjalnie dostosowany do generowania PDF, oferując możliwości tworzenia i renderowania dokumentów poprzez wykorzystanie nowoczesnych standardów HTML5 i CSS3.

Efektywność kosztowa: Jednorazowa cena na dewelopera IronPDF wypada korzystnie w porównaniu z $4,198 wieczysta + 1 rok pierwszego poziomuTX Text Control .NET Serveri modelem odnawiania około 40%/rok, szczególnie gdy wliczone są oddzielne licencje serwera na czas działania.

Brak Powiązania STA:IronPDF pracuje na standardowych wątkach pracujących w środowisku MTA w ASP.NET Core, asynchronicznych kontrolerach i kontenerach Linux bez wymagań dotyczących hostingowania kompatybilnego z STA, które ServerTextControl odziedziczył po swoim modelu wątków w stylu COM.

Brak zarządzania kontekstem: Eliminować ceremonię tworzenia ServerTextControl oraz trzy-enum (StringStreamType / BinaryStreamType / StreamType) taniec ładowania/zapisywania — ChromePdfRenderer jest bezstanowy.

Nowoczesny Silnik Renderujący: Zestaw renderujący Chromium IronPDF celuje w obecne standardy HTML5/CSS3/JavaScript zamiast ścieżki importu HTML silnika przetwarzania tekstu.

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.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespół wsparcia Iron

Jesteśmy online 24 godziny, 5 dni w tygodniu.
Czat
E-mail
Zadzwoń do mnie