La migration du kit de développement logiciel Foxit PDF vers IronPDF simplifie votre flux de travail de génération de PDF .NET en remplaçant les API complexes destinées aux entreprises par des modèles modernes et conviviaux pour les développeurs. Ce guide propose une méthode de migration complète et détaillée qui supprime le code inutile et simplifie les opérations PDF dans l'ensemble de votre code source.
Le kit de développement logiciel (SDK) Foxit PDF est une bibliothèque puissante de niveau entreprise, mais sa complexité importante peut ralentir le développement :
Système de licences complexe : La multiplicité des produits, des références et des types de licences (par développeur, par serveur, OEM, etc.) rend difficile le choix de la solution adaptée à votre projet.
Tarification Enterprise : La tarification est conçue pour les grandes organisations et peut être prohibitive pour les petites équipes ou les développeurs individuels.
Paquet natif lourd : Le package NuGet public (Foxit.SDK.Dotnet) est volumineux (~240 Mo), et les anciens projets peuvent encore contenir des références DLL directes ou des configurations de flux privé.
API verbeuse : L'initialisation de la bibliothèque avec Library.Initialize(), la vérification des codes d'erreur et les appels explicites à Library.Release() ajoutent un modèle standard à chaque opération.
Moteur HTML2PDF Séparé : La conversion HTML en PDF nécessite les binaires du moteur HTML2PDF, distribués séparément du support/ventes Foxit plutôt que d'être inclus dans le paquet NuGet.
Configuration complexe : Les paramètres nécessitent une configuration détaillée d'objets (par exemple, HTML2PDFSettingData) avec plusieurs propriétés.
Héritage C++ : les modèles d'API reflètent les origines du C++, paraissant moins naturels dans les applications C# modernes.
| Aspect | Foxit PDF SDK | IronPDF |
|---|---|---|
| Installation | Foxit.SDK.Dotnet (~240 Mo) + moteur HTML2PDF séparé | Paquet NuGet simple |
| Licence d'utilisation | Dirigé par les ventes, par développeur et par plateforme | Transparent, adapté à toutes les tailles |
| Initialisation | Library.Initialize(sn, key) | Définir la clé de licence une seule fois |
| Gestion des erreurs | Ensembles ErrorCode | Exceptions .NET Standard |
| HTML vers PDF | Téléchargement de moteur séparé | Moteur Chromium intégré |
| Style API | Héritage du C#, verbeux | Modèles .NET modernes |
| Nettoyage des ressources | Manuel Release() | IDisposable/automatic |
| Documentation | Portail documentaire d'entreprise | Tutoriels publics |
Passer de Foxit PDF à IronPDF offre des avantages tangibles en matière de développement : complexité réduite grâce à des API plus simples, développement plus rapide avec des méthodes intuitives, compatibilité .NET moderne incluant le support async/await et LINQ, une approche HTML-first utilisant des compétences web existantes, et conversion HTML incluse sans téléchargement de moteur séparé.IronPDF fonctionne sur les versions actuelles de .NET et s'associe proprement avec les modèles modernes C#.
# Create a backup branch
git checkout -b pre-ironpdf-migration
git add .
git commit -m "Backup before Foxit PDF SDKto IronPDF migration"# Find all Foxit PDF SDKreferences
grep -r "foxit\|PDFDoc\|PDFPage\|Library.Initialize\|Library.Release" --include="*.cs" --include="*.csproj" .
# Find Foxit DLL references
find . -name "*.csproj" | xargs grep -l "Foxit\|fsdk"Avant la migration, catalogue :
# Remove the Foxit NuGet package
dotnet remove package Foxit.SDK.Dotnet
# Install IronPDF
dotnet add package IronPdfSi vous avez d'anciennes références DLL Foxit directes dans .csproj (anciennes constructions), supprimez-les manuellement :
<!-- Remove these manually -->
<Reference Include="fsdk_dotnet">
<HintPath>..\libs\Foxit\fsdk_dotnet.dll</HintPath>
</Reference>Supprimez également tous les dossiers de moteur HTML2PDF qui ont été décompressés séparément.
// Before (Foxit PDF)
using foxit;
using foxit.common;
using foxit.common.fxcrt;
using foxit.pdf;
using foxit.pdf.annots;
using foxit.addon.conversion;
// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;
using IronPdf.Editing;Imports IronPdf
Imports IronPdf.Rendering
Imports IronPdf.EditingL'une des améliorations les plus significatives de cette migration Foxit PDF est l'élimination du modèle complexe d'initialisation et de nettoyage :
// Before (Foxit PDF)
string sn = "YOUR_SERIAL_NUMBER";
string key = "YOUR_LICENSE_KEY";
ErrorCode error_code = Library.Initialize(sn, key);
if (error_code != ErrorCode.e_ErrSuccess)
{
throw new Exception("Failed to initialize Foxit PDF SDK");
}
// ... your code ...
Library.Release(); // Don't forget this!
// After (IronPDF)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// That's it! No Release() neededImports System
' Before (Foxit PDF)
Dim sn As String = "YOUR_SERIAL_NUMBER"
Dim key As String = "YOUR_LICENSE_KEY"
Dim error_code As ErrorCode = Library.Initialize(sn, key)
If error_code <> ErrorCode.e_ErrSuccess Then
Throw New Exception("Failed to initialize Foxit PDF SDK")
End If
' ... your code ...
Library.Release() ' Don't forget this!
' After (IronPDF)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
' That's it! No Release() needed// Before (Foxit PDF)
Library.Initialize(sn, key);
HTML2PDFSettingData settings = new HTML2PDFSettingData();
settings.page_width = 612.0f;
settings.page_height = 792.0f;
Convert.FromHTML(htmlContent, @"C:\Foxit\html2pdf_engine", "",
settings, "output.pdf", 30);
Library.Release();
// After (IronPDF)
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");' Before (Foxit PDF)
Library.Initialize(sn, key)
Dim settings As New HTML2PDFSettingData()
settings.page_width = 612.0F
settings.page_height = 792.0F
Convert.FromHTML(htmlContent, "C:\Foxit\html2pdf_engine", "", settings, "output.pdf", 30)
Library.Release()
' After (IronPDF)
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("output.pdf")| Espace de noms Foxit PDF | Équivalent d'IronPDF |
|---|---|
foxit | IronPdf |
foxit.common | IronPdf |
foxit.common.fxcrt | N/A |
foxit.pdf | IronPdf |
foxit.pdf.annots | IronPdf.Editing |
foxit.addon.conversion | IronPdf.Rendering |
| Classe Foxit PDF SDK | Équivalent d'IronPDF |
|---|---|
Library | N/A |
PDFDoc | PdfDocument |
PDFPage | PdfDocument.Pages[i] |
HTML2PDF | ChromePdfRenderer |
TextPage | pdf.ExtractTextFromPage(i) |
Watermark | TextStamper / ImageStamper |
Security | SecuritySettings |
Form | pdf.Form |
Metadata | pdf.MetaData |
| Foxit PDFDoc | IronPDF PdfDocument |
|---|---|
new PDFDoc(path) | PdfDocument.FromFile(path) |
doc.LoadW(password) | PdfDocument.FromFile(path, password) |
doc.GetPageCount() | pdf.PageCount |
doc.GetPage(index) | pdf.Pages[index] |
doc.SaveAs(path, flags) | pdf.SaveAs(path) |
doc.Close() | pdf.Dispose() ou instruction using |
doc.InsertDocument() | PdfDocument.Merge() |
| Foxit HTML2PDF | Équivalent d'IronPDF |
|---|---|
new HTML2PDFSettingData() | new ChromePdfRenderer() |
settings.page_width | RenderingOptions.PaperSize |
settings.page_height | RenderingOptions.SetCustomPaperSize() |
Convert.FromHTML(html, engine, ...) | renderer.RenderHtmlAsPdf(html) |
Convert.FromHTML(url, engine, ...) | renderer.RenderUrlAsPdf(url) |
| Filigrane Foxit | Équivalent d'IronPDF |
|---|---|
new Watermark(doc, text, font, size, color) | new TextStamper() |
WatermarkSettings.position | VerticalAlignment + HorizontalAlignment |
WatermarkSettings.rotation | Rotation |
WatermarkSettings.opacity | Opacity |
watermark.InsertToAllPages() | pdf.ApplyStamp(stamper) |
Avant (Foxit PDF SDK):
// NuGet: Install-Package Foxit.SDK.Dotnet
// HTML-to-PDF requires the separate Foxit HTML2PDFengine (engine_path),
// obtained from Foxit support/sales — not in the NuGet package.
using foxit;
using foxit.common;
using foxit.addon.conversion;
using System;
class Program
{
static void Main()
{
Library.Initialize("sn", "key");
HTML2PDFSettingData settingData = new HTML2PDFSettingData();
settingData.page_width = 612.0f;
settingData.page_height = 792.0f;
settingData.page_mode = HTML2PDFPageMode.e_HTML2PDFPageModeSinglePage;
Convert.FromHTML(
"<html><body><h1>Hello World</h1></body></html>",
@"C:\Foxit\html2pdf_engine", // engine_path (separate download)
"", // cookies path
settingData,
"output.pdf",
30); // timeout (seconds)
Library.Release();
}
}Après (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
pdf.SaveAs("output.pdf");
}
}Imports IronPdf
Imports System
Class Program
Shared Sub Main()
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")
pdf.SaveAs("output.pdf")
End Sub
End ClassL'approche d'IronPDF permet de réduire 15+ lignes de code de configuration à seulement 4 lignes. Pas d'initialisation de bibliothèque, pas de nettoyage explicite, pas d'objets de configuration complexes. Pour plus d'options de rendu HTML, consultez la documentation HTML vers PDF.
Avant (Foxit PDF SDK):
// NuGet: Install-Package Foxit.SDK.Dotnet
// Convert.FromHTML accepts either a URL or a literal HTML string in the
// first argument; the URL form is what does URL-to-PDF.
using foxit;
using foxit.common;
using foxit.addon.conversion;
using System;
class Program
{
static void Main()
{
Library.Initialize("sn", "key");
HTML2PDFSettingData settingData = new HTML2PDFSettingData();
settingData.page_width = 612.0f;
settingData.page_height = 792.0f;
settingData.page_mode = HTML2PDFPageMode.e_HTML2PDFPageModeSinglePage;
Convert.FromHTML(
"https://www.example.com",
@"C:\Foxit\html2pdf_engine", // engine_path (separate download)
"", // cookies path
settingData,
"output.pdf",
30); // timeout (seconds)
Library.Release();
}
}Imports foxit
Imports foxit.common
Imports foxit.addon.conversion
Imports System
Module Program
Sub Main()
Library.Initialize("sn", "key")
Dim settingData As New HTML2PDFSettingData()
settingData.page_width = 612.0F
settingData.page_height = 792.0F
settingData.page_mode = HTML2PDFPageMode.e_HTML2PDFPageModeSinglePage
Convert.FromHTML(
"https://www.example.com",
"C:\Foxit\html2pdf_engine", ' engine_path (separate download)
"", ' cookies path
settingData,
"output.pdf",
30) ' timeout (seconds)
Library.Release()
End Sub
End ModuleAprès (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
pdf.SaveAs("output.pdf");
}
}Imports IronPdf
Imports System
Class Program
Shared Sub Main()
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
pdf.SaveAs("output.pdf")
End Sub
End ClassLe moteur Chromium intégré d'IronPDF gère automatiquement l'exécution de JavaScript, le rendu CSS et le contenu dynamique. En savoir plus sur la conversion d'URL en PDF.
Avant (Foxit PDF SDK):
// NuGet: Install-Package Foxit.SDK.Dotnet
using foxit;
using foxit.common;
using foxit.pdf;
using System;
class Program
{
static void Main()
{
Library.Initialize("sn", "key");
using (PDFDoc doc = new PDFDoc("input.pdf"))
{
doc.Load("");
WatermarkSettings settings = new WatermarkSettings();
settings.flags = (int)Watermark.Flags.e_FlagASPageContents;
settings.position = Position.e_PosCenter;
settings.rotation = -45.0f;
settings.opacity = 50; // 0-100 in newer SDKs
WatermarkTextProperties props = new WatermarkTextProperties();
props.font = new Font(Font.StandardID.e_StdIDHelvetica);
props.font_size = 48.0f;
props.color = 0xFF0000;
props.alignment = Alignment.e_AlignmentCenter;
Watermark watermark = new Watermark(doc, "Confidential", props, settings);
// No InsertToAllPages helper — iterate pages explicitly.
for (int i = 0; i < doc.GetPageCount(); i++)
{
using (PDFPage page = doc.GetPage(i))
{
watermark.InsertToPage(page);
}
}
doc.SaveAs("output.pdf", (int)PDFDoc.SaveFlags.e_SaveFlagNoOriginal);
}
Library.Release();
}
}Imports foxit
Imports foxit.common
Imports foxit.pdf
Imports System
Module Program
Sub Main()
Library.Initialize("sn", "key")
Using doc As New PDFDoc("input.pdf")
doc.Load("")
Dim settings As New WatermarkSettings()
settings.flags = CInt(Watermark.Flags.e_FlagASPageContents)
settings.position = Position.e_PosCenter
settings.rotation = -45.0F
settings.opacity = 50 ' 0-100 in newer SDKs
Dim props As New WatermarkTextProperties()
props.font = New Font(Font.StandardID.e_StdIDHelvetica)
props.font_size = 48.0F
props.color = &HFF0000
props.alignment = Alignment.e_AlignmentCenter
Dim watermark As New Watermark(doc, "Confidential", props, settings)
' No InsertToAllPages helper — iterate pages explicitly.
For i As Integer = 0 To doc.GetPageCount() - 1
Using page As PDFPage = doc.GetPage(i)
watermark.InsertToPage(page)
End Using
Next
doc.SaveAs("output.pdf", CInt(PDFDoc.SaveFlags.e_SaveFlagNoOriginal))
End Using
Library.Release()
End Sub
End ModuleAprès (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;
using System;
class Program
{
static void Main()
{
var pdf = PdfDocument.FromFile("input.pdf");
pdf.ApplyWatermark(new TextStamper()
{
Text = "Confidential",
FontSize = 48,
Opacity = 50,
Rotation = -45,
VerticalAlignment = VerticalAlignment.Middle,
HorizontalAlignment = HorizontalAlignment.Center
});
pdf.SaveAs("output.pdf");
}
}Imports IronPdf
Imports IronPdf.Editing
Imports System
Class Program
Shared Sub Main()
Dim pdf = PdfDocument.FromFile("input.pdf")
pdf.ApplyWatermark(New TextStamper() With {
.Text = "Confidential",
.FontSize = 48,
.Opacity = 50,
.Rotation = -45,
.VerticalAlignment = VerticalAlignment.Middle,
.HorizontalAlignment = HorizontalAlignment.Center
})
pdf.SaveAs("output.pdf")
End Sub
End ClassLa TextStamper d'IronPDF offre une configuration intuitive basée sur les propriétés au lieu d'objets de paramètres séparés et une itération manuelle des pages. Consultez la documentation complète watermarking pour des options supplémentaires.
Avant (Foxit PDF SDK):
using foxit;
using foxit.addon.conversion;
class Program
{
static void Main()
{
Library.Initialize("sn", "key");
try
{
HTML2PDFSettingData settings = new HTML2PDFSettingData();
settings.page_width = 595.0f; // A4
settings.page_height = 842.0f;
settings.page_margin_top = 100.0f;
settings.page_margin_bottom = 100.0f;
// Foxit PDF SDKhas limited header/footer support
// Often requires post-processing or additional code
Convert.FromHTML(
"https://www.example.com",
@"C:\Foxit\html2pdf_engine", // engine_path (separate download)
"", // cookies path
settings,
"webpage.pdf",
30); // timeout (seconds)
}
finally
{
Library.Release();
}
}
}Après (IronPDF):
using IronPdf;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
renderer.RenderingOptions.WaitFor.RenderDelay(3000); // Wait for JS
// Built-in header/footer support
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align:center; font-size:12pt;'>Company Report</div>",
DrawDividerLine = true
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align:right; font-size:10pt;'>Page {page} of {total-pages}</div>",
DrawDividerLine = true
};
var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
pdf.SaveAs("webpage.pdf");
}
}Imports IronPdf
Class Program
Shared Sub Main()
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PrintHtmlBackgrounds = True
renderer.RenderingOptions.WaitFor.RenderDelay(3000) ' Wait for JS
' Built-in header/footer support
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align:center; font-size:12pt;'>Company Report</div>",
.DrawDividerLine = True
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align:right; font-size:10pt;'>Page {page} of {total-pages}</div>",
.DrawDividerLine = True
}
Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
pdf.SaveAs("webpage.pdf")
End Sub
End ClassIronPDF offre une prise en charge native des en-têtes et pieds de page avec un style HTML et des espaces réservés dynamiques pour les numéros de page.
Avant (Foxit PDF SDK):
using foxit;
using foxit.pdf;
class Program
{
static void Main()
{
Library.Initialize("sn", "key");
try
{
using (PDFDoc doc = new PDFDoc("input.pdf"))
{
doc.LoadW("");
// Build the encryption data (cipher, key length, permissions)
using (StdEncryptData encryptData = new StdEncryptData(
true, // is_encrypt_metadata
(int)(PDFDoc.UserPermissions.e_PermPrint |
PDFDoc.UserPermissions.e_PermModify),
SecurityHandler.CipherType.e_CipherAES,
16)) // key length (bytes) -> AES-128
using (StdSecurityHandler securityHandler = new StdSecurityHandler())
{
securityHandler.Initialize(encryptData, "user_password", "owner_password");
doc.SetSecurityHandler(securityHandler);
}
doc.SaveAs("encrypted.pdf", (int)PDFDoc.SaveFlags.e_SaveFlagNoOriginal);
}
}
finally
{
Library.Release();
}
}
}Imports foxit
Imports foxit.pdf
Class Program
Shared Sub Main()
Library.Initialize("sn", "key")
Try
Using doc As New PDFDoc("input.pdf")
doc.LoadW("")
' Build the encryption data (cipher, key length, permissions)
Using encryptData As New StdEncryptData(True, CType(PDFDoc.UserPermissions.e_PermPrint Or PDFDoc.UserPermissions.e_PermModify, Integer), SecurityHandler.CipherType.e_CipherAES, 16) ' key length (bytes) -> AES-128
Using securityHandler As New StdSecurityHandler()
securityHandler.Initialize(encryptData, "user_password", "owner_password")
doc.SetSecurityHandler(securityHandler)
End Using
End Using
doc.SaveAs("encrypted.pdf", CType(PDFDoc.SaveFlags.e_SaveFlagNoOriginal, Integer))
End Using
Finally
Library.Release()
End Try
End Sub
End ClassAprès (IronPDF):
using IronPdf;
class Program
{
static void Main()
{
var pdf = PdfDocument.FromFile("input.pdf");
// Set passwords
pdf.SecuritySettings.OwnerPassword = "owner_password";
pdf.SecuritySettings.UserPassword = "user_password";
// Set permissions
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.FullPrintRights;
pdf.SecuritySettings.AllowUserEdits = IronPdf.Security.PdfEditSecurity.EditAll;
pdf.SecuritySettings.AllowUserCopyPasteContent = true;
pdf.SecuritySettings.AllowUserAnnotations = true;
pdf.SaveAs("encrypted.pdf");
}
}Imports IronPdf
Class Program
Shared Sub Main()
Dim pdf = PdfDocument.FromFile("input.pdf")
' Set passwords
pdf.SecuritySettings.OwnerPassword = "owner_password"
pdf.SecuritySettings.UserPassword = "user_password"
' Set permissions
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.FullPrintRights
pdf.SecuritySettings.AllowUserEdits = IronPdf.Security.PdfEditSecurity.EditAll
pdf.SecuritySettings.AllowUserCopyPasteContent = True
pdf.SecuritySettings.AllowUserAnnotations = True
pdf.SaveAs("encrypted.pdf")
End Sub
End ClassPour des performances optimales pendant votre migration PDF Foxit, réutilisez l'instance ChromePdfRenderer—elle est thread-safe :
// GOOD - Reuse renderer (thread-safe)
public class PdfService
{
private static readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();
public byte[] Generate(string html) => _renderer.RenderHtmlAsPdf(html).BinaryData;
}
// BAD - Creates new instance each time
public byte[] GenerateBad(string html)
{
var renderer = new ChromePdfRenderer(); // Wasteful
return renderer.RenderHtmlAsPdf(html).BinaryData;
}Imports System
Public Class PdfService
Private Shared ReadOnly _renderer As New ChromePdfRenderer()
Public Function Generate(html As String) As Byte()
Return _renderer.RenderHtmlAsPdf(html).BinaryData
End Function
' BAD - Creates new instance each time
Public Function GenerateBad(html As String) As Byte()
Dim renderer As New ChromePdfRenderer() ' Wasteful
Return renderer.RenderHtmlAsPdf(html).BinaryData
End Function
End ClassFoxit PDF SDK utilise des points ;IronPDF utilise des millimètres. Utilisez cette aide lors de la migration :
public static class UnitConverter
{
public static double PointsToMm(double points) => points * 0.352778;
public static double MmToPoints(double mm) => mm / 0.352778;
public static double InchesToMm(double inches) => inches * 25.4;
}
// Usage: Convert Foxit's 72 points (1 inch) to IronPDF millimeters
renderer.RenderingOptions.MarginTop = UnitConverter.PointsToMm(72); // ~25.4mmPublic Module UnitConverter
Public Function PointsToMm(points As Double) As Double
Return points * 0.352778
End Function
Public Function MmToPoints(mm As Double) As Double
Return mm / 0.352778
End Function
Public Function InchesToMm(inches As Double) As Double
Return inches * 25.4
End Function
End Module
' Usage: Convert Foxit's 72 points (1 inch) to IronPDF millimeters
renderer.RenderingOptions.MarginTop = UnitConverter.PointsToMm(72) ' ~25.4mm// GOOD - Using statement for automatic cleanup
using (var pdf = PdfDocument.FromFile("large.pdf"))
{
string text = pdf.ExtractAllText();
} // pdf is disposed automaticallyImports PdfDocument
' GOOD - Using block for automatic cleanup
Using pdf = PdfDocument.FromFile("large.pdf")
Dim text As String = pdf.ExtractAllText()
End Using ' pdf is disposed automaticallyProblème : Library.Initialize() n'existe pas dans IronPDF.
**Solution :**IronPDF utilise un modèle d'initialisation plus simple :
// Foxit PDF
Library.Initialize(sn, key);
//IronPDF- just set license key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";Problème : Le code vérifie ErrorCode.e_ErrSuccess mais IronPDF n'a pas cela.
Solution : Utiliser la gestion standard des exceptions .NET :
// Foxit PDF
ErrorCode err = doc.LoadW("");
if (err != ErrorCode.e_ErrSuccess) { /* handle error */ }
// IronPDF
try
{
var pdf = PdfDocument.FromFile("input.pdf");
}
catch (IOException ex)
{
Console.WriteLine($"Failed to load PDF: {ex.Message}");
}Imports System
Imports System.IO
' Foxit PDF
Dim err As ErrorCode = doc.LoadW("")
If err <> ErrorCode.e_ErrSuccess Then
' handle error
End If
' IronPDF
Try
Dim pdf = PdfDocument.FromFile("input.pdf")
Catch ex As IOException
Console.WriteLine($"Failed to load PDF: {ex.Message}")
End TryProblème : La méthode doc.Close() n'existe pas dans IronPDF.
Solution : Utilisez les instructions Dispose() ou using :
// Foxit PDF
doc.Close();
// IronPDF
pdf.Dispose();
// or better: wrap in using statementnetLibrary.Initialize() et Library.Release()dotnet add package IronPdfLibrary.Initialize() et Library.Release()ErrorCode par try/catchPDFDoc par PdfDocumentConvert.FromHTML(...) par ChromePdfRendererGetPage(i) à Pages[i]SaveAs(path, flags) par SaveAs(path)Close() par Dispose() ou des instructions usingTextStamper
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 et créer des manuels bien structurés et visuellement attrayants.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
