Die Migration vom Foxit PDF SDKzu IronPDF vereinfacht Ihren .NET -Workflow zur PDF-Generierung, indem komplexe, unternehmensorientierte APIs durch moderne, entwicklerfreundliche Muster ersetzt werden. Dieser Leitfaden bietet einen vollständigen, schrittweisen Migrationspfad, der unnötigen Code entfernt und PDF-Operationen in Ihrer gesamten Codebasis vereinfacht.
Das Foxit PDF SDKist eine leistungsstarke Bibliothek für Unternehmen, bringt aber eine erhebliche Komplexität mit sich, die die Entwicklung verlangsamen kann:
Komplexes Lizenzsystem: Mehrere Produkte, SKUs und Lizenztypen (pro Entwickler, pro Server, OEM usw.) erschweren die Auswahl der richtigen Option für Ihr Projekt.
Enterprise Preisgestaltung: Die Preisgestaltung ist auf große Organisationen zugeschnitten und kann für kleinere Teams oder einzelne Entwickler unerschwinglich sein.
Schweres natives Paket: Das öffentliche NuGet-Paket (Foxit.SDK.Dotnet) ist groß (~240 MB), und ältere Projekte können immer noch direkte DLL-Verweise oder private Feed-Konfigurationen enthalten.
Ausführliche API: Die Initialisierung der Bibliothek mit Library.Initialize(), das Überprüfen von Fehlercodes und explizite Library.Release()-Aufrufe fügen jedem Vorgang Boilerplate hinzu.
Separate HTML2PDF Engine: Die HTML-zu-PDF-Konvertierung erfordert die HTML2PDF-Engine-Binaries, die separat von Foxit unterstützt/verkauft werden und nicht im NuGet-Paket gebündelt sind.
Komplexe Konfiguration: Einstellungen erfordern eine detaillierte Objektkonfiguration (z. B. HTML2PDFSettingData) mit mehreren Eigenschaften.
C++-Erbe: API-Muster spiegeln die C++-Ursprünge wider und fühlen sich in modernen C#-Anwendungen weniger natürlich an.
| Aspekt | Foxit PDF SDK | IronPDF |
|---|---|---|
| Installation | Foxit.SDK.Dotnet (~240 MB) + separate HTML2PDF engine | Einfaches NuGet-Paket |
| Lizenzierung | Verkaufsgeführt, pro Entwickler pro Plattform | Transparent, für alle Größen geeignet |
| Initialisierung | Library.Initialize(sn, key) | Lizenzschlüssel einmalig festlegen |
| Fehlerbehandlung | ErrorCode Aufzählungen | Standard .NET Ausnahmen |
| HTML zu PDF | Separater Engine-Download | Eingebaute Chromium-Engine |
| API-Stil | C++-Erbe, wortreich | Moderne .NET-Muster |
| Bereinigung von Ressourcen | Manuelles Release() | IDisposable/automatisch |
| Dokumentation | Portal für Unternehmensdokumente | Öffentliche Tutorials |
Der Wechsel von Foxit PDF zu IronPDF bietet greifbare Entwicklungsverbesserungen: geringere Komplexität durch einfachere APIs, schnellere Entwicklung mit intuitiven Methoden, moderne .NET-Kompatibilität einschließlich async/await und LINQ-Unterstützung, ein HTML-erster Ansatz, der bestehende Webfähigkeiten nutzt, und HTML-Konvertierung, die ohne separaten Engine-Download enthalten ist.IronPDF läuft auf aktuellen .NET-Versionen und passt sich modernen C#-Mustern nahtlos an.
# 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"Vor der Migration, Katalog:
# Remove the Foxit NuGet package
dotnet remove package Foxit.SDK.Dotnet
# Install IronPDF
dotnet add package IronPdfWenn Sie ältere direkte Foxit-DLL-Referenzen in .csproj (ältere Builds) haben, entfernen Sie diese manuell:
<!-- Remove these manually -->
<Reference Include="fsdk_dotnet">
<HintPath>..\libs\Foxit\fsdk_dotnet.dll</HintPath>
</Reference>Entfernen Sie auch alle HTML2PDF-Engine-Ordner, die separat entpackt wurden.
// 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.EditingEine der wichtigsten Verbesserungen bei dieser Foxit-PDF-Migration ist die Abschaffung des komplexen Initialisierungs- und Bereinigungsmusters:
// 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")| Foxit PDF-Namensraum | IronPDF-Äquivalent |
|---|---|
foxit | IronPdf |
foxit.common | IronPdf |
foxit.common.fxcrt | Nicht anwendbar |
foxit.pdf | IronPdf |
foxit.pdf.annots | IronPdf.Editing |
foxit.addon.conversion | IronPdf.Rendering |
| Foxit PDF SDK-Klasse | IronPDF-Äquivalent |
|---|---|
Library | Nicht anwendbar |
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() oder using-Anweisung |
doc.InsertDocument() | PdfDocument.Merge() |
| Foxit HTML2PDF | IronPDF-Äquivalent |
|---|---|
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) |
| Foxit Wasserzeichen | IronPDF-Äquivalent |
|---|---|
new Watermark(doc, text, font, size, color) | new TextStamper() |
WatermarkSettings.position | VerticalAlignment + HorizontalAlignment |
WatermarkSettings.rotation | Rotation |
WatermarkSettings.opacity | Opacity |
watermark.InsertToAllPages() | pdf.ApplyStamp(stamper) |
Vor (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();
}
}Nach (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 ClassDer IronPDF-Ansatz reduziert 15+ Zeilen Konfigurationscode auf nur 4 Zeilen. Keine Bibliotheksinitialisierung, keine expliziten Bereinigungen, keine komplexen Einstellungsobjekte. Weitere HTML-Rendering-Optionen finden Sie in der HTML to PDF-Dokumentation.
Vor (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 ModuleNach (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 ClassDie in IronPDF integrierte Chromium-Engine kümmert sich automatisch um die Ausführung von JavaScript, CSS-Rendering und dynamische Inhalte. Erfahren Sie mehr über die URL in PDF Konvertierung.
Vor (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 ModuleNach (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 ClassTextStamper von IronPDF bietet eine intuitive auf Eigenschaften basierende Konfiguration statt separater Einstellungsobjekte und manueller Seiteniteration. Weitere Optionen finden Sie in der vollständigen Wasserzeichen-Dokumentation.
Vor (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();
}
}
}Nach (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 bietet native Kopf- und Fußzeilen-Unterstützung mit HTML-Styling und dynamischen Seitenzahl-Platzhaltern.
Vor (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 ClassNach (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 ClassFür optimale Leistung während Ihrer Foxit-PDF-Migration verwenden Sie die ChromePdfRenderer-Instanz weiter - sie ist thread-sicher:
// 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 verwendet Punkte;IronPDF arbeitet mit Millimetern. Verwenden Sie dieses Hilfsmittel während der 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 automaticallyProblem: Library.Initialize() existiert nicht in IronPDF.
**Lösung:**IronPDF verwendet ein einfacheres Initialisierungsmuster:
// Foxit PDF
Library.Initialize(sn, key);
//IronPDF- just set license key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";Problem: Der Code prüft ErrorCode.e_ErrSuccess, aber IronPDF hat das nicht.
Lösung: Verwenden Sie die standardmäßige .NET Ausnahmebehandlung:
// 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 TryProblem: doc.Close()-Methode existiert nicht in IronPDF.
Lösung: Verwenden Sie Dispose() oder using-Anweisungen:
// Foxit PDF
doc.Close();
// IronPDF
pdf.Dispose();
// or better: wrap in using statementnetLibrary.Initialize() und Library.Release()-Aufrufedotnet add package IronPdfLibrary.Initialize() und Library.Release()-AufrufeErrorCode-Prüfungen durch try/catchPDFDoc durch PdfDocumentConvert.FromHTML(...) durch ChromePdfRendererGetPage(i) auf Pages[i]SaveAs(path, flags) durch SaveAs(path)Close() durch Dispose() oder using-AnweisungenTextStamper
Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
