Wie man von iText zu IronPDF in C# migriert

Die AGPL-Lizenzfalle

iText birgt ernsthafte rechtliche und geschäftliche Risiken für kommerzielle Anwendungen, die viele Entwicklerteams zu spät erkennen:

1. AGPL Viral License: Wenn Sie iText in einer Webanwendung verwenden, verlangt die AGPL, dass Sie Ihre GESAMTE Anwendung als Open Source veröffentlichen – nicht nur den PDF-Code, sondern Ihre gesamte Codebasis. Für die meiste kommerzielle Software ist das kein Grund zur Sorge.

2. Keine unbefristete Lizenz: iText hat die unbefristete Lizenzierung abgeschafft und erzwingt jährliche Abonnementverlängerungen, was die Gesamtbetriebskosten erhöht.

3. Kosten des pdfHTML-Add-ons: Für die HTML-zu-PDF-Funktionalität ist das pdfHTML-Add-on erforderlich, das separat und gegen Aufpreis zur Basislizenz verkauft wird.

4. Komplexe Lizenzprüfungen: Bei Enterprise kommt es zu komplexen Lizenzierungsfragen und Prüfungsrisiken, die Projekte verzögern und rechtliche Risiken mit sich bringen können.

5. Nur programmatische API: iText erfordert die manuelle Erstellung von PDFs auf niedriger Ebene mit Paragraph, Table, Cell Objekten – mühsam und fehleranfällig bei komplexen Layouts.

6. Eingeschränktes modernes Web-Rendering: Selbst mit pdfHTML erfordert komplexer CSS- und JavaScriptInhalt einen erheblichen Mehraufwand.

iText vs IronPDFVergleich

Für Teams, die die Einführung von .NET 10 und C# 14 bis 2025 und 2026 planen, bietet IronPDF mit seinem HTML-first-Ansatz eine zukunftssichere Grundlage, die die bereits vorhandenen Webentwicklungskenntnisse Ihres Teams nutzt.

Geschätzter Aufwand nach Merkmalen

Paradigmen-Verschiebung

Der grundlegende Shift bei dieser iText-Migration besteht in der Umstellung von der programmatischen PDF-Erstellung auf das HTML-First-Rendering:

iText:    PdfWriter → PdfDocument → Dokument → Hinzufügen(Absatz) → Hinzufügen(Tabelle)
IronPDF: ChromePdfRenderer → RenderHtmlAsPdf(htmlString) → SaveAs()

Dieser Paradigmenwechsel ist befreiend: Anstatt das Objektmodell von iText zu lernen, nutzen Sie HTML- und CSS-Kenntnisse, die Webentwickler bereits besitzen.

Voraussetzungen

1. .NET -Umgebung: .NET Framework 4.6.2+ oder .NET Core 3.1+ / .NET 5/6/7/8/9+
2. NuGet -Zugriff: Möglichkeit zur Installation von NuGet -Paketen
3. IronPDF -Lizenz: Ihren Lizenzschlüssel erhalten Sie unter IronPDF.

NuGet-Paketänderungen

# Remove iText packages
dotnet remove package itext7
dotnet remove package itext7.pdfhtml
dotnet remove package itextsharp

# Install IronPDF
dotnet add package IronPdf

# Remove iText packages
dotnet remove package itext7
dotnet remove package itext7.pdfhtml
dotnet remove package itextsharp

# Install IronPDF
dotnet add package IronPdf

Lizenz-Konfiguration

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Identifizieren Sie die Verwendung von iText

# Find all iText references
grep -r "using iText\|using iTextSharp" --include="*.cs" .
grep -r "PdfWriter\|PdfDocument\|Document\|Paragraph\|Table\|Cell" --include="*.cs" .
grep -r "HtmlConverter\|ConverterProperties" --include="*.cs" .

# Find all iText references
grep -r "using iText\|using iTextSharp" --include="*.cs" .
grep -r "PdfWriter\|PdfDocument\|Document\|Paragraph\|Table\|Cell" --include="*.cs" .
grep -r "HtmlConverter\|ConverterProperties" --include="*.cs" .

Klassen-Zuordnungen

Namespace-Zuordnungen

Beispiel 1: Konvertierung von HTML in PDF

Vor (iText 7):

// NuGet: Install-Package itext7
using iText.Html2pdf;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>";
        string outputPath = "output.pdf";

        using (FileStream fs = new FileStream(outputPath, FileMode.Create))
        {
            HtmlConverter.ConvertToPdf(html, fs);
        }
    }
}

// NuGet: Install-Package itext7
using iText.Html2pdf;
using System.IO;

class Program
{
    static void Main()
    {
        string html = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>";
        string outputPath = "output.pdf";

        using (FileStream fs = new FileStream(outputPath, FileMode.Create))
        {
            HtmlConverter.ConvertToPdf(html, fs);
        }
    }
}

Imports iText.Html2pdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim html As String = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"
        Dim outputPath As String = "output.pdf"

        Using fs As FileStream = New FileStream(outputPath, FileMode.Create)
            HtmlConverter.ConvertToPdf(html, fs)
        End Using
    End Sub
End Class

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>";

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

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>";

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

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"

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

Der iText-Ansatz erfordert das separate iText.Html2pdf Paket (pdfHTML-Add-on, separat erhältlich), wodurch ein FileStream erstellt und alles in using Anweisungen eingeschlossen wird, um eine ordnungsgemäße Entsorgung zu gewährleisten. Die Methode HtmlConverter.ConvertToPdf() schreibt direkt in den Stream.

Der Ansatz von IronPDF ist sauberer: Erstellen Sie ein ChromePdfRenderer, rufen Sie RenderHtmlAsPdf() mit Ihrer HTML-Zeichenkette auf und rufen Sie SaveAs() mit dem resultierenden PdfDocument auf. Es gibt keine separaten Pakete, keine Stream-Verwaltung, und die Chromium-Rendering-Engine bietet hervorragende CSS3- und JavaScript-Unterstützung. Weitere Rendering-Optionen finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: Mehrere PDFs zusammenführen

Vor (iText 7):

// NuGet: Install-Package itext7
using iText.Kernel.Pdf;
using iText.Kernel.Utils;
using System.IO;

class Program
{
    static void Main()
    {
        string outputPath = "merged.pdf";
        string[] inputFiles = { "document1.pdf", "document2.pdf", "document3.pdf" };

        using (PdfWriter writer = new PdfWriter(outputPath))
        using (PdfDocument pdfDoc = new PdfDocument(writer))
        {
            PdfMerger merger = new PdfMerger(pdfDoc);

            foreach (string file in inputFiles)
            {
                using (PdfDocument sourcePdf = new PdfDocument(new PdfReader(file)))
                {
                    merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages());
                }
            }
        }
    }
}

// NuGet: Install-Package itext7
using iText.Kernel.Pdf;
using iText.Kernel.Utils;
using System.IO;

class Program
{
    static void Main()
    {
        string outputPath = "merged.pdf";
        string[] inputFiles = { "document1.pdf", "document2.pdf", "document3.pdf" };

        using (PdfWriter writer = new PdfWriter(outputPath))
        using (PdfDocument pdfDoc = new PdfDocument(writer))
        {
            PdfMerger merger = new PdfMerger(pdfDoc);

            foreach (string file in inputFiles)
            {
                using (PdfDocument sourcePdf = new PdfDocument(new PdfReader(file)))
                {
                    merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages());
                }
            }
        }
    }
}

Imports iText.Kernel.Pdf
Imports iText.Kernel.Utils
Imports System.IO

Class Program
    Shared Sub Main()
        Dim outputPath As String = "merged.pdf"
        Dim inputFiles As String() = {"document1.pdf", "document2.pdf", "document3.pdf"}

        Using writer As New PdfWriter(outputPath)
            Using pdfDoc As New PdfDocument(writer)
                Dim merger As New PdfMerger(pdfDoc)

                For Each file As String In inputFiles
                    Using sourcePdf As New PdfDocument(New PdfReader(file))
                        merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages())
                    End Using
                Next
            End Using
        End Using
    End Sub
End Class

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdfDocuments = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf"),
            PdfDocument.FromFile("document3.pdf")
        };

        var merged = PdfDocument.Merge(pdfDocuments);
        merged.SaveAs("merged.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdfDocuments = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf"),
            PdfDocument.FromFile("document3.pdf")
        };

        var merged = PdfDocument.Merge(pdfDocuments);
        merged.SaveAs("merged.pdf");
    }
}

Imports IronPdf
Imports System.Collections.Generic

Class Program
    Shared Sub Main()
        Dim pdfDocuments As New List(Of PdfDocument) From {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf"),
            PdfDocument.FromFile("document3.pdf")
        }

        Dim merged = PdfDocument.Merge(pdfDocuments)
        merged.SaveAs("merged.pdf")
    End Sub
End Class

Der iText-Merge-Vorgang erfordert erheblichen Boilerplate-Code: Erstellen eines PdfWriter für die Ausgabe, Einbetten in ein PdfDocument, Erstellen eines PdfMerger, und anschließendes Durchlaufen der Quelldateien mit verschachtelten using-Anweisungen für jedes PdfDocument und PdfReader. Sie müssen außerdem Seitenbereiche mit merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages()) angeben.

IronPDF reduziert dies auf drei Schritte: Dokumente mit PdfDocument.FromFile() laden, die statische Methode PdfDocument.Merge() mit der Liste aufrufen und speichern. Der gesamte Merge-Vorgang wird lesbar und wartbar. Erfahren Sie mehr über das Zusammenführen und Aufteilen von PDFs.

Beispiel 3: PDF mit Text und Bildern erstellen

Vor (iText 7):

// NuGet: Install-Package itext7
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using iText.IO.Image;

class Program
{
    static void Main()
    {
        string outputPath = "document.pdf";

        using (PdfWriter writer = new PdfWriter(outputPath))
        using (PdfDocument pdf = new PdfDocument(writer))
        using (Document document = new Document(pdf))
        {
            document.Add(new Paragraph("Sample PDF Document"));
            document.Add(new Paragraph("This document contains text and an image."));

            Image img = new Image(ImageDataFactory.Create("image.jpg"));
            img.SetWidth(200);
            document.Add(img);
        }
    }
}

// NuGet: Install-Package itext7
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using iText.IO.Image;

class Program
{
    static void Main()
    {
        string outputPath = "document.pdf";

        using (PdfWriter writer = new PdfWriter(outputPath))
        using (PdfDocument pdf = new PdfDocument(writer))
        using (Document document = new Document(pdf))
        {
            document.Add(new Paragraph("Sample PDF Document"));
            document.Add(new Paragraph("This document contains text and an image."));

            Image img = new Image(ImageDataFactory.Create("image.jpg"));
            img.SetWidth(200);
            document.Add(img);
        }
    }
}

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

Class Program
    Shared Sub Main()
        Dim outputPath As String = "document.pdf"

        Using writer As New PdfWriter(outputPath),
              pdf As New PdfDocument(writer),
              document As New Document(pdf)

            document.Add(New Paragraph("Sample PDF Document"))
            document.Add(New Paragraph("This document contains text and an image."))

            Dim img As New Image(ImageDataFactory.Create("image.jpg"))
            img.SetWidth(200)
            document.Add(img)
        End Using
    End Sub
End Class

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string html = @"
            <h1>Sample PDF Document</h1>
            <p>This document contains text and an image.</p>
            <img src='image.jpg' width='200' />";

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

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string html = @"
            <h1>Sample PDF Document</h1>
            <p>This document contains text and an image.</p>
            <img src='image.jpg' width='200' />";

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

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        Dim html As String = "
            <h1>Sample PDF Document</h1>
            <p>This document contains text and an image.</p>
            <img src='image.jpg' width='200' />"

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

Dieses Beispiel veranschaulicht den Paradigmenwechsel am deutlichsten. iText benötigt:

• Dreifach verschachtelte using-Anweisungen (PdfWriter, PdfDocument, Document)
• Erstellen von Paragraph-Objekten für jedes Textelement mit new Paragraph()
• Verwendung von ImageDataFactory.Create() zum Laden von Bildern
• Erstellen eines Image-Objekts und separater Aufruf von SetWidth()
• Aufruf von document.Add() für jedes Element

IronPDF verwendet Standard-HTML: <h1> für Überschriften, <p> für Absätze und <img> für Bilder mit einem width-Attribut. Webentwickler können ihre vorhandenen Kenntnisse sofort nutzen, und Designer können Dokumente mit CSS gestalten, das sie bereits kennen.

Paradigmen-Wechsel: Von Programmatic zu HTML-First

Die wichtigste Änderung bei dieser iText-Migration ist konzeptioneller Natur. iText erstellt PDFs programmatisch:

// iText approach
document.Add(new Paragraph("Title")
    .SetTextAlignment(TextAlignment.CENTER)
    .SetFontSize(24)
    .SetBold());

var table = new Table(UnitValue.CreatePercentArray(3)).UseAllAvailableWidth();
table.AddHeaderCell(new Cell().Add(new Paragraph("ID")));
table.AddHeaderCell(new Cell().Add(new Paragraph("Name")));
// ... many more lines

// iText approach
document.Add(new Paragraph("Title")
    .SetTextAlignment(TextAlignment.CENTER)
    .SetFontSize(24)
    .SetBold());

var table = new Table(UnitValue.CreatePercentArray(3)).UseAllAvailableWidth();
table.AddHeaderCell(new Cell().Add(new Paragraph("ID")));
table.AddHeaderCell(new Cell().Add(new Paragraph("Name")));
// ... many more lines

' iText approach
document.Add(New Paragraph("Title") _
    .SetTextAlignment(TextAlignment.CENTER) _
    .SetFontSize(24) _
    .SetBold())

Dim table = New Table(UnitValue.CreatePercentArray(3)).UseAllAvailableWidth()
table.AddHeaderCell(New Cell().Add(New Paragraph("ID")))
table.AddHeaderCell(New Cell().Add(New Paragraph("Name")))
' ... many more lines

IronPDF verwendet HTML und CSS:

//IronPDF approach
string html = @"
    <style>
        h1 { text-align: center; font-size: 24px; font-weight: bold; }
        table { width: 100%; border-collapse: collapse; }
        th { background-color: #4CAF50; color: white; padding: 8px; }
    </style>
    <h1>Title</h1>
    <table>
        <tr><th>ID</th><th>Name</th></tr>
    </table>";

var pdf = renderer.RenderHtmlAsPdf(html);

//IronPDF approach
string html = @"
    <style>
        h1 { text-align: center; font-size: 24px; font-weight: bold; }
        table { width: 100%; border-collapse: collapse; }
        th { background-color: #4CAF50; color: white; padding: 8px; }
    </style>
    <h1>Title</h1>
    <table>
        <tr><th>ID</th><th>Name</th></tr>
    </table>";

var pdf = renderer.RenderHtmlAsPdf(html);

Imports IronPdf

Dim html As String = "
    <style>
        h1 { text-align: center; font-size: 24px; font-weight: bold; }
        table { width: 100%; border-collapse: collapse; }
        th { background-color: #4CAF50; color: white; padding: 8px; }
    </style>
    <h1>Title</h1>
    <table>
        <tr><th>ID</th><th>Name</th></tr>
    </table>"

Dim pdf = renderer.RenderHtmlAsPdf(html)

AGPL-Lizenz abgeschafft

die AGPL-Lizenz von iText erfordert das Open-Sourcing Ihrer gesamten Webanwendung oder den Erwerb einer teuren kommerziellen Lizenz. Die kommerzielle Lizenz von IronPDF ermöglicht den Einsatz in proprietärer Software ohne virale Lizenzierungsanforderungen.

Kein pdfHTML Add-On erforderlich

iText erfordert das separate pdfHTML-Add-on für die HTML-zu-PDF-Konvertierung, das gegen Aufpreis erhältlich ist.IronPDF enthält das vollständige Chromium-basierte HTML-Rendering bereits im Basispaket.

Methoden-Ersetzungsmuster

Ausgabe 1: PdfWriter/Document Pattern

Problem: Der Code verwendet das Verschachtelungsmuster PdfWriter → PdfDocument → Document.

Lösung: Ersetzen Sie durch ChromePdfRenderer:

// Delete this iText pattern:
// using (var writer = new PdfWriter(outputPath))
// using (var pdfDoc = new PdfDocument(writer))
// using (var document = new Document(pdfDoc))

// Replace with:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);

// Delete this iText pattern:
// using (var writer = new PdfWriter(outputPath))
// using (var pdfDoc = new PdfDocument(writer))
// using (var document = new Document(pdfDoc))

// Replace with:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);

Imports IronPdf

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

Ausgabe 2: HtmlConverter nicht gefunden

Problem: Der Code verwendet iText.Html2pdf.HtmlConverter, wofür das pdfHTML-Add-on benötigt wird.

Lösung: Verwenden Sie die in IronPDF integrierte HTML-Rendering-Funktion:

// iText (requires pdfHTML add-on)
HtmlConverter.ConvertToPdf(html, fileStream);

//IronPDF(built-in)
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);

// iText (requires pdfHTML add-on)
HtmlConverter.ConvertToPdf(html, fileStream);

//IronPDF(built-in)
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(outputPath);

' iText (requires pdfHTML add-on)
HtmlConverter.ConvertToPdf(html, fileStream)

' IronPDF(built-in)
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs(outputPath)

Ausgabe 3: Komplexität von PdfMerger

Problem: iText's PdfMerger erfordert verschachtelte Reader und die Angabe eines Seitenbereichs.

Lösung: Verwenden Sie die statische Merge-Methode von IronPDF:

// iText merger pattern (delete this)
// using (PdfDocument pdfDoc = new PdfDocument(writer))
// {
//     PdfMerger merger = new PdfMerger(pdfDoc);
//     foreach (string file in inputFiles)
//     {
//         using (PdfDocument sourcePdf = new PdfDocument(new PdfReader(file)))
//         {
//             merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages());
//         }
//     }
// }

//IronPDF(simple)
var merged = PdfDocument.Merge(pdfDocuments);
merged.SaveAs("merged.pdf");

// iText merger pattern (delete this)
// using (PdfDocument pdfDoc = new PdfDocument(writer))
// {
//     PdfMerger merger = new PdfMerger(pdfDoc);
//     foreach (string file in inputFiles)
//     {
//         using (PdfDocument sourcePdf = new PdfDocument(new PdfReader(file)))
//         {
//             merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages());
//         }
//     }
// }

//IronPDF(simple)
var merged = PdfDocument.Merge(pdfDocuments);
merged.SaveAs("merged.pdf");

Imports System.Collections.Generic

' iText merger pattern (delete this)
' Using pdfDoc As New PdfDocument(writer)
'     Dim merger As New PdfMerger(pdfDoc)
'     For Each file As String In inputFiles
'         Using sourcePdf As New PdfDocument(New PdfReader(file))
'             merger.Merge(sourcePdf, 1, sourcePdf.GetNumberOfPages())
'         End Using
'     Next
' End Using

' IronPDF(simple)
Dim merged = PdfDocument.Merge(pdfDocuments)
merged.SaveAs("merged.pdf")

Vor der Migration

• Inventarisierung aller iText-API-Aufrufe im Quellcode
• Programmatische PDF-Konstruktionsmuster identifizieren (Absatz, Tabelle, Zelle)
• Verwendung des Document HtmlConverters (pdfHTML-Add-on)
• AGPL-Compliance-Risiko bewerten -IronPDF-Lizenzschlüssel erhalten

Code-Migration

• Entfernen Sie die iText NuGet Pakete: dotnet remove package itext7
• Installieren Sie das IronPDFNuGet Paket: dotnet add package IronPdf
• Namespace-Importe aktualisieren (using iText.* → using IronPdf)
• Ersetzen Sie das Muster Document durch ChromePdfRenderer
• Konvertiere Cell in HTML-Elemente
• Ersetzen Sie HtmlConverter.ConvertToPdf() durch RenderHtmlAsPdf()
• Aktualisierung der Zusammenführungsvorgänge auf PdfDocument.Merge()
• Lizenzschlüsselinitialisierung beim Start hinzufügen

Testen

• Alle PDF-Generierungspfade testen
• Überprüfen Sie, ob die visuelle Ausgabe den Erwartungen entspricht.
• Test mit komplexem HTML/CSS-Inhalt
• Benchmark-Leistung

Nach der Migration

• Entfernen Sie die iText-Lizenzdateien und -Verweise.
• Dokumentation aktualisieren
• iText-Abonnement kündigen (falls zutreffend)
• Archivierung des alten iText-Codes