Iron Suite for .NET

10 bibliothèques .NET. Une suite de documents complète.

Découvrez Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

COMPARAISON

PeachPDF vs IronPDF : Guide de comparaison technique

Curtis Chau

Updated: 21 avril 2026

Comprendre le traitement des documents Telerik

Telerik Document Processing fait partie de la suite Telerik, connue pour fournir des composants et des solutions d'interface utilisateur complets pour le développement d'applications .NET. En tant qu'offre commerciale sous la licence DevCraft, elle permet aux développeurs d'intégrer des capacités de traitement PDF directement dans leurs projets.

La bibliothèque utilise une architecture de document de flux qui convertit HTML en un modèle intermédiaire RadFlowDocument avant de générer la sortie PDF. Cette approche nécessite plusieurs fournisseurs de format (HtmlFormatProvider, PdfFormatProvider) et une manipulation explicite du modèle de document.

Telerik Document Processing offre des fonctionnalités non seulement pour la génération de PDF, mais aussi pour la gestion de divers formats de documents tels que Word, Excel et PowerPoint, offrant une flexibilité au-delà des PDF pour les organisations déjà investies dans l'écosystème Telerik.

Comprendre IronPDF

IronPDF fournit une bibliothèque PDF moderne et autonome qui simplifie la conversion de HTML en PDF à l'aide d'un moteur de rendu Chromium. La bibliothèque offre une prise en charge solide de HTML5, CSS3 et JavaScript, garantissant la fidélité du rendu des documents à travers les normes web modernes.

IronPDF utilise une approche de rendu direct sans modèle de document intermédiaire, convertissant le contenu HTML en PDF en une seule étape. Cette simplicité architecturale se traduit par une réduction du nombre de lignes de code et de la complexité de l'API.

Le problème du rendu CSS/HTML

L'une des différences techniques les plus importantes entre ces bibliothèques réside dans la manière dont elles gèrent le HTML et le CSS modernes.

Traitement des documents Telerik CSS Limitations (en anglais)

Telerik Document Processing présente des problèmes fondamentaux lors de la manipulation de HTML/CSS modernes. La bibliothèque convertit HTML en un modèle intermédiaire de document de flux, qui :

Aplatit la structure HTML — les éléments <div> deviennent des paragraphes
Ignores modern CSS - Flexbox et Grid layouts fail
Breaks Bootstrap - Les systèmes de colonnes ne fonctionnent pas correctement
Perte de formatage - Les sélecteurs complexes sont ignorés

Les développeurs ont exprimé des inquiétudes quant à l'incapacité de la bibliothèque à prendre pleinement en charge les normes CSS modernes. Les constructions CSS3 et les mises en page Bootstrap sont confrontées à des problèmes de compatibilité, ce qui entraîne des changements importants dans la mise en page et le rendu.

Moteur IronPDF Chromium

IronPDF utilise un moteur de rendu basé sur Chromium qui gère les feuilles de style complexes, les fichiers CSS externes et les conceptions réactives exactement comme ils apparaissent dans les navigateurs. Cela inclut une prise en charge complète de :

Fonctionnalités CSS3, y compris Flexbox et Grid
Mises en page Bootstrap 5
Variables CSS
Sélecteurs complexes
Unités modernes comme calc() et rem

Aperçu de la comparaison des fonctionnalités

Fonctionnalité / Critères	Traitement des documents Telerik	IronPDF
Support HTML/CSS	Limité, problèmes avec Bootstrap et CSS3	Complet, y compris Bootstrap 5
Rendu HTML	Conversion d'un document Flow	Rendu direct de Chromium
Support CSS3	Limité, de nombreuses fonctionnalités échouent	CSS3 complet
Flexbox	Non pris en charge	Prise en charge
CSS Grid	Non pris en charge	Prise en charge
Bootstrap	Broken (aplatissement de div)	Prise en charge
JavaScript	Non pris en charge	Prise en charge
Performance des fichiers	Exception OutOfMemory sur les fichiers volumineux	Stable et efficace
Modèle de licence	Commercial, partie de DevCraft	Licence autonome simple
Complexité de l'API	Complexe (fournisseurs, modèles)	Simple (une classe)

Conversion HTML en PDF

La conversion HTML-PDF révèle les différences architecturales fondamentales entre ces bibliothèques.

Traitement des documents Telerik HTML to PDF (en anglais)

Telerik nécessite des fournisseurs de formats multiples et une gestion explicite du modèle de document :

// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;

string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("output.pdf"))
{
    pdfProvider.Export(document, output);
}

// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;

string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("output.pdf"))
{
    pdfProvider.Export(document, output);
}

Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports System.IO

Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

Dim htmlProvider As New HtmlFormatProvider()
Dim document As RadFlowDocument = htmlProvider.Import(html)

Dim pdfProvider As New PdfFormatProvider()
Using output As FileStream = File.OpenWrite("output.pdf")
    pdfProvider.Export(document, output)
End Using

Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports System.IO

Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

Dim htmlProvider As New HtmlFormatProvider()
Dim document As RadFlowDocument = htmlProvider.Import(html)

Dim pdfProvider As New PdfFormatProvider()
Using output As FileStream = File.OpenWrite("output.pdf")
    pdfProvider.Export(document, output)
End Using

Cette approche nécessite :

Plusieurs packages NuGet (Telerik.Documents.Flow, Telerik.Documents.Flow.FormatProviders.Pdf)
Création de HtmlFormatProvider pour importer du HTML dans RadFlowDocument
Création de PdfFormatProvider séparés pour l'exportation PDF
Gestion manuelle de FileStream
Comprendre le modèle intermédiaire du document de flux

IronPDF HTML vers PDF

IronPDF assure la conversion directe de HTML en PDF :

// NuGet: Install-Package IronPdf
using IronPdf;

string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

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

// NuGet: Install-Package IronPdf
using IronPdf;

string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

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

Imports IronPdf

Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

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

Imports IronPdf

Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"

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

La méthode RenderHtmlAsPdf convertit le contenu HTML directement en PDF à l'aide du moteur de rendu Chromium. Pas de modèles de documents intermédiaires, pas de fournisseurs multiples, pas de gestion manuelle des flux - l'ensemble de l'opération s'effectue en trois lignes de code.

Conversion d'URL en PDF

La conversion de pages web en PDF témoigne d'une lacune critique en matière de capacités.

Traitement des documents Telerik URL to PDF (en anglais)

Telerik Document Processing n'offre pas de conversion native d'URL en PDF. Les développeurs doivent télécharger manuellement le contenu HTML avant de le traiter :

// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

string url = "https://example.com";

using HttpClient client = new HttpClient();
string html = await client.GetStringAsync(url);

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("webpage.pdf"))
{
    pdfProvider.Export(document, output);
}

// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

string url = "https://example.com";

using HttpClient client = new HttpClient();
string html = await client.GetStringAsync(url);

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("webpage.pdf"))
{
    pdfProvider.Export(document, output);
}

Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports System.IO
Imports System.Net.Http
Imports System.Threading.Tasks

Module Module1
    Sub Main()
        Dim url As String = "https://example.com"

        Using client As New HttpClient()
            Dim html As String = Await client.GetStringAsync(url)

            Dim htmlProvider As New HtmlFormatProvider()
            Dim document As RadFlowDocument = htmlProvider.Import(html)

            Dim pdfProvider As New PdfFormatProvider()
            Using output As FileStream = File.OpenWrite("webpage.pdf")
                pdfProvider.Export(document, output)
            End Using
        End Using
    End Sub
End Module

Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports System.IO
Imports System.Net.Http
Imports System.Threading.Tasks

Module Module1
    Sub Main()
        Dim url As String = "https://example.com"

        Using client As New HttpClient()
            Dim html As String = Await client.GetStringAsync(url)

            Dim htmlProvider As New HtmlFormatProvider()
            Dim document As RadFlowDocument = htmlProvider.Import(html)

            Dim pdfProvider As New PdfFormatProvider()
            Using output As FileStream = File.OpenWrite("webpage.pdf")
                pdfProvider.Export(document, output)
            End Using
        End Using
    End Sub
End Module

Cette approche de contournement :

Nécessite une configuration manuelle de HttpClient et une gestion des requêtes HTTP
Téléchargements uniquement du HTML statique (pas d'exécution de JavaScript)
Impossible de rendre le contenu dynamique ou les SPA
Les feuilles de style externes peuvent ne pas être correctement résolues
Ajoute de la complexité et des points d'échec potentiels

IronPDF URL vers PDF

IronPDF assure la conversion native d'URL en PDF :

// NuGet: Install-Package IronPdf
using IronPdf;

string url = "https://example.com";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf(url);
pdf.SaveAs("webpage.pdf");

// NuGet: Install-Package IronPdf
using IronPdf;

string url = "https://example.com";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf(url);
pdf.SaveAs("webpage.pdf");

Imports IronPdf

Dim url As String = "https://example.com"

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf(url)
pdf.SaveAs("webpage.pdf")

Imports IronPdf

Dim url As String = "https://example.com"

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf(url)
pdf.SaveAs("webpage.pdf")

La méthode RenderUrlAsPdf navigue vers l'URL à l'aide du moteur Chromium, exécute JavaScript, effectue le rendu de la page complète et capture le résultat. Pas de traitement HTTP manuel, pas de contenu dynamique manquant, pas de problèmes de résolution CSS.

Opérations de fusion de fichiers PDF

La combinaison de plusieurs documents PDF montre des différences significatives dans la complexité des API.

Traitement des documents Telerik PDF Merge (en anglais)

Telerik nécessite une itération manuelle des pages et une gestion du modèle de document :

// NuGet: Install-Package Telerik.Documents.Fixed
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
using System.IO;

PdfFormatProvider provider = new PdfFormatProvider();

RadFixedDocument document1;
using (FileStream input = File.OpenRead("document1.pdf"))
{
    document1 = provider.Import(input);
}

RadFixedDocument document2;
using (FileStream input = File.OpenRead("document2.pdf"))
{
    document2 = provider.Import(input);
}

RadFixedDocument mergedDocument = new RadFixedDocument();
foreach (var page in document1.Pages)
{
    mergedDocument.Pages.Add(page);
}
foreach (var page in document2.Pages)
{
    mergedDocument.Pages.Add(page);
}

using (FileStream output = File.OpenWrite("merged.pdf"))
{
    provider.Export(mergedDocument, output);
}

// NuGet: Install-Package Telerik.Documents.Fixed
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
using System.IO;

PdfFormatProvider provider = new PdfFormatProvider();

RadFixedDocument document1;
using (FileStream input = File.OpenRead("document1.pdf"))
{
    document1 = provider.Import(input);
}

RadFixedDocument document2;
using (FileStream input = File.OpenRead("document2.pdf"))
{
    document2 = provider.Import(input);
}

RadFixedDocument mergedDocument = new RadFixedDocument();
foreach (var page in document1.Pages)
{
    mergedDocument.Pages.Add(page);
}
foreach (var page in document2.Pages)
{
    mergedDocument.Pages.Add(page);
}

using (FileStream output = File.OpenWrite("merged.pdf"))
{
    provider.Export(mergedDocument, output);
}

Imports Telerik.Windows.Documents.Fixed.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Fixed.Model
Imports System.IO

Dim provider As New PdfFormatProvider()

Dim document1 As RadFixedDocument
Using input As FileStream = File.OpenRead("document1.pdf")
    document1 = provider.Import(input)
End Using

Dim document2 As RadFixedDocument
Using input As FileStream = File.OpenRead("document2.pdf")
    document2 = provider.Import(input)
End Using

Dim mergedDocument As New RadFixedDocument()
For Each page In document1.Pages
    mergedDocument.Pages.Add(page)
Next
For Each page In document2.Pages
    mergedDocument.Pages.Add(page)
Next

Using output As FileStream = File.OpenWrite("merged.pdf")
    provider.Export(mergedDocument, output)
End Using

Imports Telerik.Windows.Documents.Fixed.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Fixed.Model
Imports System.IO

Dim provider As New PdfFormatProvider()

Dim document1 As RadFixedDocument
Using input As FileStream = File.OpenRead("document1.pdf")
    document1 = provider.Import(input)
End Using

Dim document2 As RadFixedDocument
Using input As FileStream = File.OpenRead("document2.pdf")
    document2 = provider.Import(input)
End Using

Dim mergedDocument As New RadFixedDocument()
For Each page In document1.Pages
    mergedDocument.Pages.Add(page)
Next
For Each page In document2.Pages
    mergedDocument.Pages.Add(page)
Next

Using output As FileStream = File.OpenWrite("merged.pdf")
    provider.Export(mergedDocument, output)
End Using

Cette approche nécessite :

PdfFormatProvider pour les opérations d'importation et d'exportation
Objets FileStream séparés pour chaque document
Itération manuelle à travers les collections de pages
Création d'un nouveau RadFixedDocument pour le résultat fusionné
Appels explicites de Pages.Add() pour chaque page
Gestion complexe des ressources avec plusieurs déclarations using

IronPDF PDF Merge

IronPDF propose une opération de fusion déclarative :

// NuGet: Install-Package IronPdf
using IronPdf;

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;

var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");

var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");

Imports IronPdf

Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")

Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")

Imports IronPdf

Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")

Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")

La méthode PdfDocument.Merge() accepte plusieurs documents et renvoie un résultat combiné. Pas d'itération de page, pas de construction manuelle de modèle de document, pas de gestion de flux - l'opération s'effectue en quatre lignes de code.

Limites techniques essentielles

Telerik Questions relatives au traitement des documents

Problème	Impact	Solution IronPDF
Limitations de l'analyse CSS	Les cadres CSS modernes tels que Bootstrap échouent	Prise en charge complète de Chromium CSS
Conversion de div en paragraphe	La structure HTML est aplatie, les mises en page sont cassées	Rendu HTML direct
Modèle de document de flux	Force la conversion intermédiaire	HTML natif vers PDF
Questions CSS externes	Sélecteurs complexes ignorés	Prise en charge complète des fichiers CSS
Questions de mémoire	OutOfMemoryException sur des documents volumineux	Streaming efficace

Considérations de performance

Il y a des cas signalés de limitations de mémoire avec le traitement de documents Telerik, notamment avec de gros fichiers où la bibliothèque génère des erreurs OutOfMemoryException.IronPDF est conçu pour traiter des documents volumineux sans rencontrer de problèmes de mémoire, ce qui en fait un choix fiable pour la production de documents en grande quantité.

Comparaison de la complexité des API

L'architecture complexe de Telerik

Telerik nécessite la compréhension de plusieurs concepts et classes :

// Telerik - Complex provider/model architecture

// 1. Import HTML to Flow Document
HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(htmlContent);

// 2. Manually modify document model
RadFlowDocumentEditor editor = new RadFlowDocumentEditor(document);
Section section = document.Sections.First();
Paragraph para = section.Blocks.AddParagraph();
para.Inlines.AddText("Additional text");

// 3. Configure export settings
PdfExportSettings exportSettings = new PdfExportSettings();
exportSettings.ImageQuality = ImageQuality.High;

// 4. Create PDF provider with settings
PdfFormatProvider pdfProvider = new PdfFormatProvider();
pdfProvider.ExportSettings = exportSettings;

// 5. Export to bytes
byte[] pdfBytes = pdfProvider.Export(document);

// 6. Save to file
File.WriteAllBytes("output.pdf", pdfBytes);

// Telerik - Complex provider/model architecture

// 1. Import HTML to Flow Document
HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(htmlContent);

// 2. Manually modify document model
RadFlowDocumentEditor editor = new RadFlowDocumentEditor(document);
Section section = document.Sections.First();
Paragraph para = section.Blocks.AddParagraph();
para.Inlines.AddText("Additional text");

// 3. Configure export settings
PdfExportSettings exportSettings = new PdfExportSettings();
exportSettings.ImageQuality = ImageQuality.High;

// 4. Create PDF provider with settings
PdfFormatProvider pdfProvider = new PdfFormatProvider();
pdfProvider.ExportSettings = exportSettings;

// 5. Export to bytes
byte[] pdfBytes = pdfProvider.Export(document);

// 6. Save to file
File.WriteAllBytes("output.pdf", pdfBytes);

Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.Model
Imports Telerik.Windows.Documents.Flow.Model.Editing
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf.Export
Imports System.IO
Imports System.Linq

' Telerik - Complex provider/model architecture

' 1. Import HTML to Flow Document
Dim htmlProvider As New HtmlFormatProvider()
Dim document As RadFlowDocument = htmlProvider.Import(htmlContent)

' 2. Manually modify document model
Dim editor As New RadFlowDocumentEditor(document)
Dim section As Section = document.Sections.First()
Dim para As Paragraph = section.Blocks.AddParagraph()
para.Inlines.AddText("Additional text")

' 3. Configure export settings
Dim exportSettings As New PdfExportSettings()
exportSettings.ImageQuality = ImageQuality.High

' 4. Create PDF provider with settings
Dim pdfProvider As New PdfFormatProvider()
pdfProvider.ExportSettings = exportSettings

' 5. Export to bytes
Dim pdfBytes As Byte() = pdfProvider.Export(document)

' 6. Save to file
File.WriteAllBytes("output.pdf", pdfBytes)

Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.Model
Imports Telerik.Windows.Documents.Flow.Model.Editing
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf.Export
Imports System.IO
Imports System.Linq

' Telerik - Complex provider/model architecture

' 1. Import HTML to Flow Document
Dim htmlProvider As New HtmlFormatProvider()
Dim document As RadFlowDocument = htmlProvider.Import(htmlContent)

' 2. Manually modify document model
Dim editor As New RadFlowDocumentEditor(document)
Dim section As Section = document.Sections.First()
Dim para As Paragraph = section.Blocks.AddParagraph()
para.Inlines.AddText("Additional text")

' 3. Configure export settings
Dim exportSettings As New PdfExportSettings()
exportSettings.ImageQuality = ImageQuality.High

' 4. Create PDF provider with settings
Dim pdfProvider As New PdfFormatProvider()
pdfProvider.ExportSettings = exportSettings

' 5. Export to bytes
Dim pdfBytes As Byte() = pdfProvider.Export(document)

' 6. Save to file
File.WriteAllBytes("output.pdf", pdfBytes)

L'approche simple d'IronPDF

//IronPDF- Direct rendering, no intermediate models

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

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

// That's it - 3 lines vs 15+ lines!

//IronPDF- Direct rendering, no intermediate models

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

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

// That's it - 3 lines vs 15+ lines!

Imports IronPdf

'IronPDF- Direct rendering, no intermediate models

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("output.pdf")

' That's it - 3 lines vs 15+ lines!

Imports IronPdf

'IronPDF- Direct rendering, no intermediate models

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("output.pdf")

' That's it - 3 lines vs 15+ lines!

Quand les équipes envisagent la migration du traitement des documents Telerik

Plusieurs facteurs incitent les équipes de développement à évaluer les alternatives à Traitement des documents Telerik:

Les limitations de rendu CSS empêchent les mises en page web modernes de s'afficher correctement. Les systèmes de colonnes Flexbox, CSS Grid et Bootstrap échouent parce que le modèle Flow Document aplatit la structure HTML en paragraphes séquentiels.

L'absence de support JavaScript rend impossible le rendu de contenu dynamique, de SPA ou de pages qui dépendent d'un rendu côté client.

Problèmes de mémoire avec de grands documents causent des erreurs OutOfMemoryException lors du traitement de fichiers PDF importants, limitant l'évolutivité pour la production à volume élevé de documents.

Les exigences du pack DevCraft peuvent ne pas correspondre aux équipes qui n'ont besoin que de la fonctionnalité PDF. La suite complète comprend de nombreux composants qui peuvent s'avérer inutiles pour répondre à des besoins précis en matière de génération de PDF.

L'architecture API complexe avec de multiples fournisseurs de formats, des modèles de documents et une gestion explicite des flux augmente le temps de développement et les frais de maintenance par rapport à des alternatives plus simples.

Forts et compromis

Traitement des documents Telerik Points forts

Intégration avec la suite Telerik DevCraft
Documentation complète et soutien de la communauté
Prise en charge de plusieurs formats (Word, Excel, PowerPoint au-delà des PDF)
Présence établie dans l'entreprise

Limitations du traitement des documents par Telerik

Prise en charge limitée de CSS3 (Flexbox, Grid fail)
Les mises en page Bootstrap brisées par l'aplatissement des divs
Pas d'exécution JavaScript
Problèmes de mémoire avec les fichiers volumineux
API complexe avec plusieurs fournisseurs
Exigences du pack DevCraft

Les points forts d'IronPDF

Prise en charge complète de CSS3, y compris Flexbox et Grid
Compatibilité Bootstrap 5
Exécution JavaScript
Conversion native d'URL en PDF
Performances stables pour les fichiers volumineux
API simple, à classe unique
Licence autonome

Conclusion

Telerik Document Processing et IronPDF répondent à des préférences architecturales et à des exigences techniques différentes. Traitement des documents Telerikoffre une valeur ajoutée aux organisations profondément ancrées dans l'écosystème Telerik DevCraft, qui ont besoin d'une gestion étendue des formats de documents à travers Word, Excel et PowerPoint, en plus des PDF.

Pour les développeurs à la recherche d'une conversion HTML-PDF robuste avec une prise en charge complète des normes web modernes,IronPDF fournit les fonctionnalités CSS3, Flexbox, Grid et JavaScript que le modèle de document Flow de Telerik ne peut pas offrir. La capacité à rendre correctement les mises en page Bootstrap, à gérer efficacement les fichiers volumineux et à convertir les URL directement en PDF répond à des exigences courantes auxquelles Traitement des documents Telerikse heurte.

Lors de l'évaluation de la migration de Traitement des documents Telerikvers IronPDF, les équipes doivent prendre en compte leurs exigences spécifiques autour de la fidélité du rendu CSS, de l'exécution JavaScript, des performances de la mémoire et de la simplicité de l'API. Pour les équipes visant .NET 10 et C# 14 en 2026 avec des flux de travail de génération de documents web modernes, l'approche d'IronPDF basée sur Chromium offre des capacités qui s'alignent sur les pratiques de développement web contemporaines.

Pour des conseils de mise en œuvre, explorez le tutoriel HTML-to-PDF d'IronPDF et documentation couvrant les modèles de génération de PDF pour les applications .NET modernes.

Veuillez noter: Telerik est une marque déposée de son propriétaire respectif. Ce site n'est pas affilié à, approuvé par, ou sponsorisé par Progress Software. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.