Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Guias de Migração
  4. migração de tallcomponents para ironpdf
GUIAS DE MIGRAçãO

Como migrar de TallComponents para IronPDF em C#

Curtis Chau
Curtis Chau
Atualizado:

Quando a Apryse adquiriu a TallComponents, o cenário de PDFs em .NET mudou significativamente. Com o Componentes altos não estando mais disponível para novas licenças e os usuários existentes sendo redirecionados para o iText SDK, os desenvolvedores que utilizam o TallPDF e o PDFKit enfrentam uma decisão inevitável: migrar agora ou correr o risco de executar um software sem suporte e com bugs de renderização conhecidos até 2026 e além.

Este guia fornece um caminho de migração completo do Componentes altos para o IronPDF, incluindo instruções passo a passo, mapeamentos de API e exemplos de código reais para ajudar desenvolvedores .NET profissionais a fazerem a transição de forma eficiente.

Por que a migração para Componentes altos agora é obrigatória

TallComponents já foi um nome respeitado na geração de PDFs em C#. A biblioteca oferecia fluxos de trabalho de documentos baseados em XML e manipulação programática de PDFs. Não entanto, a aquisição pela Apryse pôs fim à venda de novas licenças, alterando fundamentalmente os cálculos das equipes de desenvolvimento.

Limitações críticas de componentes altos

A decisão de migrar não se resume apenas ao suporte do fornecedor — a Componentes altos possui uma dívida técnica significativa:

Descontinuação do produto: Não há novas licenças disponíveis desde a aquisição da Apryse. O site oficial da Componentes altos afirma explicitamente que a venda de novas licenças foi encerrada, orientando os potenciais usuários a adotarem o iText SDK.

Sem suporte para conversão de HTML para PDF: Ao contrário das bibliotecas de PDF modernas, o Componentes altos não oferece suporte a conversões diretas de HTML para PDF. Os desenvolvedores das plataformas de suporte confirmaram essa limitação, apontando soluções de terceiros como o Pechkin como alternativas.

Problemas de renderização documentados: Os registros de alterações revelam extensos problemas de renderização, incluindo renderização de páginas em branco, gráficos ausentes, processamento não confiável de imagens JPEG e exibição incorreta de fontes. Esses erros nunca foram resolvidos antes da descontinuação do produto.

Sem suporte ou atualizações: Sem manutenção ativa, quaisquer vulnerabilidades de segurança ou problemas de compatibilidade com o .NET 10 e o C# 14 permanecerão sem solução.

IronPDF: Uma alternativa moderna ao TallComponents

O IronPDF resolve as principais limitações que tornavam os Componentes altos problemáticos para os fluxos de trabalho de desenvolvimento modernos:

Recurso Componentes altos IronPDF
Situação atual da venda Descontinuado para novas vendas Desenvolvido e vendido ativamente
Suporte para conversão de HTML em PDF Não Sim (HTML5/CSS3 com Chromium)
Fidelidade de renderização Problemas e erros conhecidos Confiabilidade comprovada
Instalação Complexo, Manual Simples com o NuGet
Suporte ao Cliente Transição para o SDK do iText Apoio ativo e comunidade
Usabilidade futura Fim da vida Viabilidade a longo prazo

O contraste é gritante: o Componentes altos oferece uma abordagem baseada em XML, de uma era diferente do desenvolvimento .NET , enquanto o IronPDF fornece renderização HTML com tecnologia Chromium, que se alinha à forma como os desenvolvedores criam aplicativos atualmente.

Guia rápido: Migração do Componentes altos para o IronPDF

Passo 1: Substituir pacotes NuGet

Remova todos os pacotes Componentes altos do seu projeto:

# Remove Componentes altos packages
dotnet remove package TallComponents.PDF.Kit
dotnet remove package TallComponents.PDF.Layout
dotnet remove package TallComponents.PDF.Layout.Drawing
# Remove Componentes altos packages
dotnet remove package TallComponents.PDF.Kit
dotnet remove package TallComponents.PDF.Layout
dotnet remove package TallComponents.PDF.Layout.Drawing
SHELL

Instale o IronPDF:

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

Para estruturas especializadas, o IronPDF oferece pacotes de extensão dedicados:

Servidor 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

Framework MVC:

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

Etapa 2: Atualizar Namespaces

Substitua os namespaces Componentes altos pelo namespace 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;
// 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

Etapa 3: Inicialize sua licença

Adicionar inicialização de licença na inicialização do aplicativo:

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

Referência de mapeamento da API Componentes altos para IronPDF

Compreender como os conceitos do Componentes altos se relacionam com o IronPDF acelera o processo de migração:

Componentes altos IronPDF Notas
Document ChromePdfRenderer Criar um renderizador para geração de PDFs
Section Automático Seções derivadas da estrutura HTML
TextParagraph Elementos de texto HTML Use <p>, <h1>, <div>, etc.
ImageParagraph <img> tag Imagens HTML padrão
TableParagraph HTML <table> Tabelas HTML padrão
Font CSS font-family Suporte completo para fontes da web
document.Write() pdf.SaveAs() Salvar em arquivo
document.Write(stream) pdf.BinaryData ou pdf.Stream Saída de fluxo
Page.Canvas Renderização HTML/CSS Não é necessário manipular manualmente a tela.
XmlDocument.Generate() RenderHtmlAsPdf() HTML substitui XML
PdfKit.Merger.Merge() PdfDocument.Merge() Mesclar vários PDFs
Document.Security pdf.SecuritySettings Configuração de segurança de PDF
PageLayout RenderingOptions Configurações de página e margens

Exemplos de migração de código

Converter HTML para PDF

O Componentes altos não possui suporte nativo para conversão de HTML em PDF. A solução alternativa envolve a criação de fragmentos a partir do texto, o que na verdade não renderiza HTML:

Abordagem 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

Abordagem 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

O ChromePdfRenderer do IronPDF usa um mecanismo Chromium genuíno, fornecendo suporte completo a HTML5 e CSS3. Isso significa que seus PDFs serão exibidos exatamente como apareceriam em um navegador moderno. Saiba mais no tutorial de HTML para PDF .

Unir vários PDFs

A fusão de PDFs demonstra a diferença de verbosidade entre Componentes altos e IronPDF.

Abordagem 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

Abordagem 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

A versão Componentes altos requer iteração manual de páginas e clonagem. IronPDF reduz isso a uma única chamada PdfDocument.Merge(). Para cenários de mesclagem avançados, consulte a documentação de mesclagem em PDF .

Adicionando marcas d'água

A inclusão de marcas d'água em PDFs revela outra diferença significativa na experiência do desenvolvedor.

Abordagem 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

Abordagem 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

A classe TextStamper do IronPDF oferece opções intuitivas de alinhamento e iteração automática de páginas. O guia de carimbos e marcas d'água abrange opções adicionais de personalização.

Assinaturas digitais

A assinatura de documentos é fundamental para aplicações empresariais.

Abordagem 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

Abordagem 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

A API de assinatura do IronPDF inclui propriedades de metadados adicionais para informações de contato, localização e motivo da assinatura — importantes para registros de auditoria. Consulte a documentação sobre assinatura digital para obter detalhes completos sobre a implementação.

Comparação de recursos: Componentes altos vs IronPDF

Recurso Componentes altos IronPDF
Status ❌ DESCONTINUADO ✅ Ativo
Apoiar ❌ Nenhum ✅ Completo
Atualizações ❌ Nenhum ✅ Regular
Criação de conteúdo : HTML para PDF Não Cromo completo
URL para PDF Não Sim
Suporte a CSS Não CSS3 completo
JavaScript Não ES2024 completo
Modelos XML Sim Não é necessário
Operações com PDF : Mesclar PDFs Sim Sim
Dividir PDFs Sim Sim
Marcas d'água Manual Embutido
Cabeçalhos/Rodapés baseado em XML HTML/CSS
: Segurança : Proteção por senha Sim Sim
Assinaturas digitais Sim Sim
Criptografia Sim Sim
PDF/A Limitado Sim
Problemas conhecidos : Páginas em branco ⚠️ Bug documentado Nenhum
Gráficos ausentes ⚠️ Bug documentado Nenhum
Problemas com fontes ⚠️ Bug documentado Nenhum
: Desenvolvimento : Curva de Aprendizagem Alto (XML) Baixo (HTML)
Documentação Desatualizado Extenso
Comunidade Nenhum Ativo

Lista de verificação para migração de componentes altos

Tarefas pré-migração

Faça uma auditoria em sua base de código para identificar todos os usos 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

Documente os modelos e layouts XML existentes — eles serão convertidos para HTML. Identificar as configurações de segurança atualmente em uso, observando as configurações de senha e as implementações de assinatura digital.

Tarefas de atualização de código

  1. Remova os pacotes Componentes altos via NuGet.
  2. Instale o pacote IronPDF
  3. Converter layouts XML em modelos HTML
  4. Substitua o modelo de seção/parágrafo por elementos HTML.
  5. Atualize o código da tabela para usar tabelas HTML padrão.
  6. Converter cabeçalhos/rodapés em HTML com HtmlHeaderFooter
  7. Atualize as configurações de segurança para usar pdf.SecuritySettings
  8. Adicionar inicialização de licença na inicialização

Migração de cabeçalhos e rodapés

O Componentes altos utiliza cabeçalhos baseados em XML. O IronPDF fornece cabeçalhos baseados em HTML com espaços reservados dinâmicos:

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

Saiba mais sobre cabeçalhos e rodapés no IronPDF .

Fase de Testes

  1. Compare a saída visual entre as versões Componentes altos e IronPDF.
  2. Verifique se os problemas com páginas em branco foram resolvidos.
  3. Teste todos os modelos de documento.
  4. Validar a funcionalidade de mesclagem de PDFs
  5. Testar assinaturas digitais
  6. Confirme se as configurações de segurança foram aplicadas corretamente.

Cronograma de migração recomendado

Dado que o Componentes altos foi descontinuado e não recebe mais suporte, a migração deve ser feita com urgência:

Semana 1: Auditar a base de código e identificar todos os usos de TallComponents.
Semana 2: Converter modelos de documentos de XML para HTML
Semana 3: Atualização de segurança, fusão e assinatura de código
Semana 4: Testes e implantação em produção

Adiar significa executar software sem suporte e com bugs de renderização documentados — um risco que nenhuma equipe de desenvolvimento profissional deveria aceitar rumo a 2026.

Principais benefícios da migração

A migração do Componentes altos para o IronPDF oferece vantagens imediatas:

Mecanismo de renderização Chromium moderno: O suporte completo a CSS e JavaScript garante que os PDFs sejam renderizados exatamente como esperado, eliminando os bugs de página em branco e gráficos ausentes documentados no TallComponents.

Manutenção ativa e atualizações de segurança: o IronPDF recebe atualizações regulares, garantindo a compatibilidade com as versões atuais e futuras do .NET , incluindo o .NET 10.

Melhor integração com .NET : suporte nativo async/await e padrões de API modernos estão alinhados com as práticas atuais de desenvolvimento em C#.

Documentação completa: Tutoriais abrangentes e referências de API facilitam a implementação rápida.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim