Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Guides de migration
  4. migration de tallcomponents vers IronPDF
GUIDES DE MIGRATION

Comment migrer de TallComponents à IronPDF en C#

Curtis Chau
Curtis Chau
Mis à jour:

Lorsqu'Apryse a acquis TallComponents, le paysage des PDF .NET a changé de manière significative. TallComponentsn'étant plus disponible pour les nouvelles licences et les utilisateurs existants étant redirigés vers iText SDK, les développeurs utilisant TallPDF et PDFKit sont confrontés à une décision inévitable : migrer maintenant ou risquer d'utiliser un logiciel non pris en charge avec des bogues de rendu connus jusqu'en 2026 et au-delà.

Ce guide fournit un chemin de migration complet de TallComponentsvers IronPDF, y compris des instructions étape par étape, des mappages d'API et des exemples de code réels pour aider les développeurs .NET professionnels à effectuer une transition efficace.

Pourquoi la migration vers TallComponentsest désormais obligatoire

TallComponents était autrefois un nom respecté dans le domaine de la génération de PDF en C#. La bibliothèque proposait des flux de documents basés sur XML et la manipulation programmatique de PDF. Cependant, l'acquisition par Apryse a mis fin aux ventes de nouvelles licences, changeant fondamentalement le calcul pour les équipes de développement.

Limitations critiques de TallComponents

La décision de migrer n'est pas seulement liée à l'assistance du fournisseur - TallComponents a une dette technique importante :

Arrêt de la commercialisation du produit : aucune nouvelle licence n'est disponible depuis l'acquisition par Apryse. Le site officiel de TallComponentsindique explicitement que les ventes de nouvelles licences sont terminées et oriente les utilisateurs potentiels vers iText SDK.

Absence de prise en charge de la conversion HTML vers PDF : contrairement aux bibliothèques PDF modernes, TallComponentsne prend pas en charge les conversions directes de HTML vers PDF. Les développeurs des plateformes d'assistance ont confirmé cette limitation, en indiquant des solutions tierces telles que Pechkin comme alternatives.

Problèmes de rendu documentés : les journaux de modifications révèlent de nombreux problèmes de rendu, notamment l'affichage de pages blanches, des graphismes manquants, une gestion peu fiable des images JPEG et un affichage incorrect des polices. Ces bogues n'ont jamais été résolus avant l'arrêt de la production.

Aucun support ni mise à jour : sans maintenance active, les failles de sécurité ou les problèmes de compatibilité avec .NET 10 et C# 14 resteront sans solution.

IronPDF: Une alternative moderne à TallComponents

IronPDF s'attaque aux principales limitations qui ont rendu les TallComponentsproblématiques pour les flux de travail de développement modernes :

Fonction TallComponents IronPDF
État actuel de la vente Abandonné pour les nouvelles ventes Développé et vendu activement
Prise en charge HTML-PDF Non Oui (HTML5/CSS3 avec Chromium)
Fidélité du rendu Bogues et problèmes connus Fiabilité éprouvée
Installation Complexe, Manuel Simple avec NuGet
Assistance à la clientèle Transition vers iText SDK Support actif et communauté
Facilité d'utilisation future Fin de vie Viabilité à long terme

Le contraste est saisissant : TallComponentspropose une approche basée sur XML datant d'une autre époque du développement .NET, tandis qu'IronPDF offre un rendu HTML alimenté par Chromium qui s'aligne sur la façon dont les développeurs créent des applications aujourd'hui.

Démarrage rapide : Migration de TallComponentsvers IronPDF

Étape 1 : Remplacer les paquets NuGet

Supprimez tous les paquets TallComponentsde votre projet :

# Remove TallComponentspackages
dotnet remove package TallComponents.PDF.Kit
dotnet remove package TallComponents.PDF.Layout
dotnet remove package TallComponents.PDF.Layout.Drawing
# Remove TallComponentspackages
dotnet remove package TallComponents.PDF.Kit
dotnet remove package TallComponents.PDF.Layout
dotnet remove package TallComponents.PDF.Layout.Drawing
SHELL

InstallezIronPDF:

# Install IronPDF
dotnet add package IronPdf
# Install IronPDF
dotnet add package IronPdf
SHELL

Pour les frameworks spécialisés,IronPDFpropose des packs d'extension dédiés :

Serveur Blazor:

PM > Install-Package IronPdf.Extensions.Blazor
PM > Install-Package IronPdf.Extensions.Blazor
SHELL

MAUI :

PM > Install-Package IronPdf.Extensions.Maui
PM > Install-Package IronPdf.Extensions.Maui
SHELL

Cadre MVC:

PM > Install-Package IronPdf.Extensions.Mvc.Framework
PM > Install-Package IronPdf.Extensions.Mvc.Framework
SHELL

Étape 2 : Mise à jour des espaces de noms

Remplacer les espaces de noms TallComponentspar l'espace de nomsIronPDF:

// Before (TallComponents)
using TallComponents.PDF.Kit;
using TallComponents.PDF.Layout;
using TallComponents.PDF.Layout.Drawing;
using TallComponents.PDF.Layout.Paragraphs;

// After (IronPDF)
using IronPdf;
// Before (TallComponents)
using TallComponents.PDF.Kit;
using TallComponents.PDF.Layout;
using TallComponents.PDF.Layout.Drawing;
using TallComponents.PDF.Layout.Paragraphs;

// After (IronPDF)
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Étape 3 : initialisation de votre licence

Ajouter l'initialisation de la licence au démarrage de l'application :

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

TallComponentstoIronPDFAPI Mapping Reference (Référence de mappage de l'API de TallComponentsvers IronPDF)

Comprendre comment les concepts de TallComponentss'adaptent àIronPDFaccélère le processus de migration :

TallComponents IronPDF Notes
Document ChromePdfRenderer Créer un moteur de rendu pour la génération de PDF
Section Automatique Sections dérivées de la structure HTML
TextParagraph Éléments de texte HTML Utilisez <p>, <h1>, <div>, etc.
ImageParagraph <img> balise Images HTML standard
TableParagraph HTML <table> Tableaux HTML standard
Font CSS font-family Polices Web entièrement prises en charge
document.Write() pdf.SaveAs() Enregistrer dans un fichier
document.Write(stream) pdf.BinaryData ou pdf.Stream Flux de sortie
Page.Canvas Rendu HTML/CSS Aucune manipulation manuelle du canevas n'est nécessaire
XmlDocument.Generate() RenderHtmlAsPdf() HTML remplace XML
PdfKit.Merger.Merge() PdfDocument.Merge() Fusionner plusieurs PDF
Document.Security pdf.SecuritySettings Configuration de la sécurité des PDF
PageLayout RenderingOptions Mise en page et marges

Exemples de migration de code

Conversion de HTML en PDF

TallComponents ne prend pas en charge la conversion native de HTML en PDF. La solution de contournement consiste à créer des fragments de texte, ce qui n'entraîne pas de rendu HTML :

Approche de TallComponents:

// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using System.IO;

class Program
{
    static void Main()
    {
        // Create a new document
        using (Document document = new Document())
        {
            string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

            // Create HTML fragment
            Fragment fragment = Fragment.FromText(html);

            // Add to document
            Section section = document.Sections.Add();
            section.Fragments.Add(fragment);

            // Save to file
            using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
            {
                document.Write(fs);
            }
        }
    }
}
// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using System.IO;

class Program
{
    static void Main()
    {
        // Create a new document
        using (Document document = new Document())
        {
            string html = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>";

            // Create HTML fragment
            Fragment fragment = Fragment.FromText(html);

            // Add to document
            Section section = document.Sections.Add();
            section.Fragments.Add(fragment);

            // Save to file
            using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
            {
                document.Write(fs);
            }
        }
    }
}
Imports TallComponents.PDF.Kit
Imports System.IO

Class Program
    Shared Sub Main()
        ' Create a new document
        Using document As New Document()
            Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF from HTML.</p></body></html>"

            ' Create HTML fragment
            Dim fragment As Fragment = Fragment.FromText(html)

            ' Add to document
            Dim section As Section = document.Sections.Add()
            section.Fragments.Add(fragment)

            ' Save to file
            Using fs As New FileStream("output.pdf", FileMode.Create)
                document.Write(fs)
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

Approche IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;

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

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

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

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

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

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

IronPDF utilise un véritable moteur Chromium, offrant une prise en charge complète de HTML5 et CSS3. Cela signifie que vos PDF s'affichent exactement comme ils le feraient dans un navigateur moderne. Pour en savoir plus, consultez le tutoriel HTML to PDF tutorial.

Fusionner plusieurs fichiers PDF

La fusion de PDF démontre la différence de verbosité entre TallComponentset IronPDF.

Approche de TallComponents:

// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using System.IO;

class Program
{
    static void Main()
    {
        // Create output document
        using (Document outputDoc = new Document())
        {
            // Load first PDF
            using (FileStream fs1 = new FileStream("document1.pdf", FileMode.Open))
            using (Document doc1 = new Document(fs1))
            {
                foreach (Page page in doc1.Pages)
                {
                    outputDoc.Pages.Add(page.Clone());
                }
            }

            // Load second PDF
            using (FileStream fs2 = new FileStream("document2.pdf", FileMode.Open))
            using (Document doc2 = new Document(fs2))
            {
                foreach (Page page in doc2.Pages)
                {
                    outputDoc.Pages.Add(page.Clone());
                }
            }

            // Save merged document
            using (FileStream output = new FileStream("merged.pdf", FileMode.Create))
            {
                outputDoc.Write(output);
            }
        }
    }
}
// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using System.IO;

class Program
{
    static void Main()
    {
        // Create output document
        using (Document outputDoc = new Document())
        {
            // Load first PDF
            using (FileStream fs1 = new FileStream("document1.pdf", FileMode.Open))
            using (Document doc1 = new Document(fs1))
            {
                foreach (Page page in doc1.Pages)
                {
                    outputDoc.Pages.Add(page.Clone());
                }
            }

            // Load second PDF
            using (FileStream fs2 = new FileStream("document2.pdf", FileMode.Open))
            using (Document doc2 = new Document(fs2))
            {
                foreach (Page page in doc2.Pages)
                {
                    outputDoc.Pages.Add(page.Clone());
                }
            }

            // Save merged document
            using (FileStream output = new FileStream("merged.pdf", FileMode.Create))
            {
                outputDoc.Write(output);
            }
        }
    }
}
Imports TallComponents.PDF.Kit
Imports System.IO

Class Program
    Shared Sub Main()
        ' Create output document
        Using outputDoc As New Document()
            ' Load first PDF
            Using fs1 As New FileStream("document1.pdf", FileMode.Open)
                Using doc1 As New Document(fs1)
                    For Each page As Page In doc1.Pages
                        outputDoc.Pages.Add(page.Clone())
                    Next
                End Using
            End Using

            ' Load second PDF
            Using fs2 As New FileStream("document2.pdf", FileMode.Open)
                Using doc2 As New Document(fs2)
                    For Each page As Page In doc2.Pages
                        outputDoc.Pages.Add(page.Clone())
                    Next
                End Using
            End Using

            ' Save merged document
            Using output As New FileStream("merged.pdf", FileMode.Create)
                outputDoc.Write(output)
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

Approche IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        // Load PDFs
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        // Merge PDFs
        var merged = PdfDocument.Merge(pdf1, pdf2);

        // Save merged document
        merged.SaveAs("merged.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        // Load PDFs
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        // Merge PDFs
        var merged = PdfDocument.Merge(pdf1, pdf2);

        // Save merged document
        merged.SaveAs("merged.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        ' Load PDFs
        Dim pdf1 = PdfDocument.FromFile("document1.pdf")
        Dim pdf2 = PdfDocument.FromFile("document2.pdf")

        ' Merge PDFs
        Dim merged = PdfDocument.Merge(pdf1, pdf2)

        ' Save merged document
        merged.SaveAs("merged.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

La version TallComponentsnécessite une itération et un clonage manuels des pages.IronPDFréduit cela à un seul appel PdfDocument.Merge(). Pour les scénarios de fusion avancés, voir la documentation sur la fusion de fichiers PDF.

Ajouter des filigranes

Le filigrane des PDF révèle une autre différence significative dans l'expérience des développeurs.

Approche de TallComponents:

// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using TallComponents.PDF.Layout;
using System.IO;
using System.Drawing;

class Program
{
    static void Main()
    {
        // Load existing PDF
        using (FileStream fs = new FileStream("input.pdf", FileMode.Open))
        using (Document document = new Document(fs))
        {
            // Iterate through pages
            foreach (Page page in document.Pages)
            {
                // Create watermark text
                TextShape watermark = new TextShape();
                watermark.Text = "CONFIDENTIAL";
                watermark.Font = new Font("Arial", 60);
                watermark.PenColor = Color.FromArgb(128, 255, 0, 0);
                watermark.X = 200;
                watermark.Y = 400;
                watermark.Rotate = 45;

                // Add to page
                page.Overlay.Shapes.Add(watermark);
            }

            // Save document
            using (FileStream output = new FileStream("watermarked.pdf", FileMode.Create))
            {
                document.Write(output);
            }
        }
    }
}
// NuGet: Install-Package TallComponents.PDF.Kit
using TallComponents.PDF.Kit;
using TallComponents.PDF.Layout;
using System.IO;
using System.Drawing;

class Program
{
    static void Main()
    {
        // Load existing PDF
        using (FileStream fs = new FileStream("input.pdf", FileMode.Open))
        using (Document document = new Document(fs))
        {
            // Iterate through pages
            foreach (Page page in document.Pages)
            {
                // Create watermark text
                TextShape watermark = new TextShape();
                watermark.Text = "CONFIDENTIAL";
                watermark.Font = new Font("Arial", 60);
                watermark.PenColor = Color.FromArgb(128, 255, 0, 0);
                watermark.X = 200;
                watermark.Y = 400;
                watermark.Rotate = 45;

                // Add to page
                page.Overlay.Shapes.Add(watermark);
            }

            // Save document
            using (FileStream output = new FileStream("watermarked.pdf", FileMode.Create))
            {
                document.Write(output);
            }
        }
    }
}
Imports TallComponents.PDF.Kit
Imports TallComponents.PDF.Layout
Imports System.IO
Imports System.Drawing

Class Program
    Shared Sub Main()
        ' Load existing PDF
        Using fs As New FileStream("input.pdf", FileMode.Open)
            Using document As New Document(fs)
                ' Iterate through pages
                For Each page As Page In document.Pages
                    ' Create watermark text
                    Dim watermark As New TextShape()
                    watermark.Text = "CONFIDENTIAL"
                    watermark.Font = New Font("Arial", 60)
                    watermark.PenColor = Color.FromArgb(128, 255, 0, 0)
                    watermark.X = 200
                    watermark.Y = 400
                    watermark.Rotate = 45

                    ' Add to page
                    page.Overlay.Shapes.Add(watermark)
                Next

                ' Save document
                Using output As New FileStream("watermarked.pdf", FileMode.Create)
                    document.Write(output)
                End Using
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

Approche IronPDF:

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

class Program
{
    static void Main()
    {
        // Load existing PDF
        var pdf = PdfDocument.FromFile("input.pdf");

        // Create watermark
        var watermark = new TextStamper()
        {
            Text = "CONFIDENTIAL",
            FontSize = 60,
            Opacity = 50,
            Rotation = 45,
            VerticalAlignment = VerticalAlignment.Middle,
            HorizontalAlignment = HorizontalAlignment.Center
        };

        // Apply watermark to all pages
        pdf.ApplyStamp(watermark);

        // Save watermarked PDF
        pdf.SaveAs("watermarked.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;

class Program
{
    static void Main()
    {
        // Load existing PDF
        var pdf = PdfDocument.FromFile("input.pdf");

        // Create watermark
        var watermark = new TextStamper()
        {
            Text = "CONFIDENTIAL",
            FontSize = 60,
            Opacity = 50,
            Rotation = 45,
            VerticalAlignment = VerticalAlignment.Middle,
            HorizontalAlignment = HorizontalAlignment.Center
        };

        // Apply watermark to all pages
        pdf.ApplyStamp(watermark);

        // Save watermarked PDF
        pdf.SaveAs("watermarked.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Editing

Class Program
    Shared Sub Main()
        ' Load existing PDF
        Dim pdf = PdfDocument.FromFile("input.pdf")

        ' Create watermark
        Dim watermark = New TextStamper() With {
            .Text = "CONFIDENTIAL",
            .FontSize = 60,
            .Opacity = 50,
            .Rotation = 45,
            .VerticalAlignment = VerticalAlignment.Middle,
            .HorizontalAlignment = HorizontalAlignment.Center
        }

        ' Apply watermark to all pages
        pdf.ApplyStamp(watermark)

        ' Save watermarked PDF
        pdf.SaveAs("watermarked.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

La classe TextStamper d'IronPDF offre des options d'alignement intuitives et une itération automatique des pages. Le guide de l'estampillage et des filigranes couvre des options de personnalisation supplémentaires.

Signatures numériques

La signature des documents est essentielle pour les applications d'entreprise.

Approche de TallComponents:

using TallComponents.PDF.Kit;
using TallComponents.PDF.Kit.Signing;

Document document = new Document("unsigned.pdf");

// Load certificate
X509Certificate2 cert = new X509Certificate2("certificate.pfx", "password");

// Create signature
SignatureHandler handler = new SignatureHandler(cert);
document.Sign(handler);

document.Write("signed.pdf");
using TallComponents.PDF.Kit;
using TallComponents.PDF.Kit.Signing;

Document document = new Document("unsigned.pdf");

// Load certificate
X509Certificate2 cert = new X509Certificate2("certificate.pfx", "password");

// Create signature
SignatureHandler handler = new SignatureHandler(cert);
document.Sign(handler);

document.Write("signed.pdf");
Imports TallComponents.PDF.Kit
Imports TallComponents.PDF.Kit.Signing
Imports System.Security.Cryptography.X509Certificates

Dim document As New Document("unsigned.pdf")

' Load certificate
Dim cert As New X509Certificate2("certificate.pfx", "password")

' Create signature
Dim handler As New SignatureHandler(cert)
document.Sign(handler)

document.Write("signed.pdf")
$vbLabelText   $csharpLabel

Approche IronPDF:

using IronPdf;
using IronPdf.Signing;

var pdf = PdfDocument.FromFile("unsigned.pdf");

// Sign with certificate
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningContact = "support@company.com",
    SigningLocation = "New York",
    SigningReason = "Document Approval"
};

pdf.Sign(signature);
pdf.SaveAs("signed.pdf");
using IronPdf;
using IronPdf.Signing;

var pdf = PdfDocument.FromFile("unsigned.pdf");

// Sign with certificate
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningContact = "support@company.com",
    SigningLocation = "New York",
    SigningReason = "Document Approval"
};

pdf.Sign(signature);
pdf.SaveAs("signed.pdf");
Imports IronPdf
Imports IronPdf.Signing

Dim pdf = PdfDocument.FromFile("unsigned.pdf")

' Sign with certificate
Dim signature = New PdfSignature("certificate.pfx", "password") With {
    .SigningContact = "support@company.com",
    .SigningLocation = "New York",
    .SigningReason = "Document Approval"
}

pdf.Sign(signature)
pdf.SaveAs("signed.pdf")
$vbLabelText   $csharpLabel

L'API de signature d'IronPDF comprend des propriétés de métadonnées supplémentaires pour les informations de contact, l'emplacement et la raison de la signature - important pour les pistes d'audit. Explorez la documentation sur la signature numérique pour obtenir des détails complets sur la mise en œuvre.

Comparaison des fonctionnalités : TallComponentsvs IronPDF

Fonction TallComponents IronPDF
Statut ❌ DISCONTINUED ✅ Actif
Support ❌ Aucun ✅ Complet
Mises à jour ❌ Aucun ✅ Régulier
: Création de contenu : HTML vers PDF Non Chromium complet
URL vers PDF Non Oui
Support CSS Non CSS3 complet
JavaScript Non ES2024 complet
Modèles XML Oui Pas nécessaire
: Opérations PDF : Fusionner des PDF Oui Oui
Diviser les PDF Oui Oui
Filigranes Manuel Intégré
En-têtes/Pieds de page Basé sur XML HTML/CSS
: Sécurité : Protection par mot de passe Oui Oui
Signatures numériques Oui Oui
Chiffrement Oui Oui
PDF/A Limité Oui
Problèmes connus : Pages vierges ⚠️ Bogue documenté Aucun
Graphiques manquants ⚠️ Bogue documenté Aucun
Problèmes de police ⚠️ Bogue documenté Aucun
: Développement : Courbe d'apprentissage Haut (XML) Faible (HTML)
Documentation Obsolète Une traduction
Communauté Aucun Actif

Liste de contrôle pour la migration vers TallComponents

Tâches préalables à la migration

Auditez votre base de code pour identifier toutes les utilisations de TallComponents:

grep -r "using TallComponents" --include="*.cs" .
grep -r "Document\|Section\|TextParagraph" --include="*.cs" .
grep -r "using TallComponents" --include="*.cs" .
grep -r "Document\|Section\|TextParagraph" --include="*.cs" .
SHELL

Documenter les modèles et les mises en page XML existants - ceux-ci seront convertis en HTML. Identifier les paramètres de sécurité actuellement utilisés, en notant les configurations de mots de passe et les implémentations de signatures numériques.

Tâches de mise à jour du code

  1. Supprimer les paquets TallComponentsvia NuGet
  2. Installer le paquet IronPDF
  3. Convertir des mises en page XML en modèles HTML
  4. Remplacer le modèle Section/Paragraphe par des éléments HTML
  5. Mise à jour du code des tableaux pour utiliser les tableaux HTML standard
  6. Convertissez les en-têtes/pieds de page en HTML avec HtmlHeaderFooter
  7. Mettez à jour les paramètres de sécurité pour utiliser pdf.SecuritySettings
  8. Ajouter l'initialisation de la licence au démarrage

Migration des en-têtes et des pieds de page

TallComponents utilise des en-têtes basés sur XML.IronPDFfournit des en-têtes basés sur HTML avec des espaces réservés dynamiques :

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align:center;'>Header Text</div>",
    MaxHeight = 25
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align:center;'>Footer Text</div>",
    MaxHeight = 25
};
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align:center;'>Header Text</div>",
    MaxHeight = 25
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align:center;'>Footer Text</div>",
    MaxHeight = 25
};
Imports System

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div style='text-align:center;'>Header Text</div>",
    .MaxHeight = 25
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div style='text-align:center;'>Footer Text</div>",
    .MaxHeight = 25
}
$vbLabelText   $csharpLabel

En savoir plus sur les en-têtes et pieds de page dans IronPDF.

Phase de test

  1. Comparer la sortie visuelle entre les versions de TallComponentset d'IronPDF
  2. Vérifier que les problèmes de pages blanches sont résolus
  3. Tester tous les modèles de documents
  4. Valider la fonctionnalité de fusion de PDF
  5. Tester les signatures numériques
  6. Confirmer que les paramètres de sécurité s'appliquent correctement

Temps de migration recommandé

Étant donné que TallComponentsn'est plus utilisé et qu'il n'y a plus d'assistance, la migration doit être effectuée de toute urgence :

Semaine 1 : Auditer le code source et identifier toutes les utilisations de TallComponents Semaine 2 : Convertir les modèles de documents XML en HTML
Semaine 3 : Mise à jour du code de sécurité, de fusion et de signature
Semaine 4 : Tests et déploiement en production

Tout retard implique l'utilisation d'un logiciel non pris en charge avec des bogues de rendu documentés - un risque qu'aucune équipe de développement professionnelle ne devrait accepter à l'aube de 2026.

Avantages principaux de la migration

Le passage de TallComponentsàIronPDFprésente des avantages immédiats :

Moteur de rendu Chromium moderne : la prise en charge complète des CSS et JavaScriptgarantit un rendu des PDF conforme aux attentes, éliminant ainsi les bugs de page blanche et de graphismes manquants documentés dans TallComponents.

Maintenance active et mises à jour de sécurité :IronPDFreçoit des mises à jour régulières, garantissant la compatibilité avec les versions actuelles et futures de .NET , y compris .NET 10.

Meilleure intégration .NET : la prise en charge native d'async/await et les modèles d'API modernes s'alignent sur les pratiques de développement C# contemporaines.

Documentation complète : des tutoriels et des références API détaillés facilitent une mise en œuvre rapide.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi