Wie man Schriftarten in PDFs C# setzt

PdfiumViewerverstehen

PdfiumViewer (NuGet-Paket PdfiumViewer, Repo pvginkel/PdfiumViewer, Apache 2.0) ist ein .NET-Wrapper um Googles PDFium-Rendering-Engine – die gleiche Engine, die in Chrome verwendet wird – und bietet PDF-Anzeige und Rasterung für Windows Forms-Anwendungen.

PdfiumViewer ist ein Viewer und Renderer, kein Generator. Es unterstützt keine PDF-Erstellung, -Bearbeitung oder -Manipulation, und seine Text-API (PdfDocument.GetPdfText(int page)) gibt reinen Seitentext ohne Layout oder Wortkoordinaten zurück. Das Upstream-Repository wurde am 2. August 2019 archiviert und der letzte NuGet-Release (2.13.0) erschien am 6. November 2017 – bestehender Code funktioniert weiterhin, aber es gibt keine weiteren Fixes, .NET 6+-Updates oder CVE-Patches.

Kritische PdfiumViewer-Einschränkungen

1. Nur Viewer/Renderer: Kann keine PDFs aus HTML, Bildern oder programmgesteuert erstellen. Die Fähigkeiten von PdfiumViewerbeschränken sich auf das Anzeigen und Rasterisieren – es unterstützt keine PDF-Erstellung, Bearbeitung, Zusammenführung oder andere Manipulationsfunktionen.

2. Nur Windows Forms/Windows: Entwickelt um System.Drawing und WinForms-Steuerelemente; nicht für andere UI-Frameworks konzipiert, und System.Drawing.Common ist Windows-only unter .NET 6+.

3. Keine PDF-Manipulation: Kann PDF-Inhalte nicht zusammenführen, teilen oder ändern.

4. Native Binärabhängigkeiten: Erfordert plattformspezifische PDFium-Binaries über PdfiumViewer.Native.x86.v8-xfa und PdfiumViewer.Native.x86_64.v8-xfa (oder die Varianten ohne V8 / ohne XFA).

5. Archiviert am Ursprung: Repo archiviert 2019-08-02; letzte NuGet-Veröffentlichung 2.13.0 (2017-11-06); keine weiteren Updates.

6. Nur textebene Seitenauszüge: PdfDocument.GetPdfText(int page) gibt reinen Seitentext zurück – keine Wortkoordinaten, keine Layout-Rekonstruktion und kein OCR für bilder- oder grafikbasierte PDFs.

7. Kein HTML zu PDF: PDFium analysiert kein HTML. Um ein PDF aus HTML zu erzeugen, benötigen Sie einen separaten Generator (wkhtmltopdf, IronPDF, PuppeteerSharp usw.) und können dann das Ergebnis mit PdfiumVieweranzeigen oder rasterisieren.

8. Keine Header/Footer: Kann keine Seitennummern oder wiederholten Inhalte hinzufügen.

9. Keine Wasserzeichen: Kann Dokumente nicht mit Überlagerungen stempeln.

10. Keine Sicherheitsfunktionen: Kann PDFs nicht verschlüsseln oder mit einem Passwort schützen.

PdfiumViewervs IronPDF Vergleich

Für Teams, die moderne .NET-Frameworks anstreben, bietet IronPDF eine umfassende, aktiv gepflegte Grundlage, die mit allen .NET-Anwendungstypen funktioniert und die Windows Forms-Beschränkung sowie die native Binärkomplexität beseitigt.

Voraussetzungen

1. .NET -Umgebung: .NET Framework 4.6.2+ oder .NET Core 3.1+ / .NET 5/6/7/8/9+
2. NuGet -Zugriff: Möglichkeit zur Installation von NuGet -Paketen
3. IronPDF -Lizenz: Ihren Lizenzschlüssel erhalten Sie unter IronPDF.

NuGet-Paketänderungen

# Remove PdfiumViewerpackages
dotnet remove package PdfiumViewer
dotnet remove package PdfiumViewer.Native.x86.v8-xfa
dotnet remove package PdfiumViewer.Native.x86_64.v8-xfa

# Install IronPDF
dotnet add package IronPdf

# Remove PdfiumViewerpackages
dotnet remove package PdfiumViewer
dotnet remove package PdfiumViewer.Native.x86.v8-xfa
dotnet remove package PdfiumViewer.Native.x86_64.v8-xfa

# Install IronPDF
dotnet add package IronPdf

Lizenz-Konfiguration

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

PdfiumViewer-Verwendung identifizieren

# Find PdfiumViewerusage
grep -r "PdfiumViewer\|PdfViewer\|PdfDocument\.Load" --include="*.cs" .

# Find native binary references
grep -r "pdfium\.dll\|Native\.x86\|Native\.x64" --include="*.csproj" .

# Find viewer control usage
grep -r "PdfViewer" --include="*.cs" --include="*.Designer.cs" .

# Find PdfiumViewerusage
grep -r "PdfiumViewer\|PdfViewer\|PdfDocument\.Load" --include="*.cs" .

# Find native binary references
grep -r "pdfium\.dll\|Native\.x86\|Native\.x64" --include="*.csproj" .

# Find viewer control usage
grep -r "PdfViewer" --include="*.cs" --include="*.Designer.cs" .

Namensraumänderungen

// PdfiumViewer
using PdfiumViewer;

// IronPDF
using IronPdf;
using IronPdf.Rendering;
using IronPdf.Editing;

// PdfiumViewer
using PdfiumViewer;

// IronPDF
using IronPdf;
using IronPdf.Rendering;
using IronPdf.Editing;

Imports PdfiumViewer

Imports IronPdf
Imports IronPdf.Rendering
Imports IronPdf.Editing

Kernklassen-Zuordnungen

Zuordnungen beim Laden von Dokumenten

Zuordnungen von Dokumenteigenschaften

Seiten-Rendering-Zuordnungen

Zuordnungen von Dokumenten speichern

Neue oder wesentlich erweiterte Funktionen im Vergleich zu PdfiumViewer

Beispiel 1: Textextraktion aus PDF

Vor (PdfiumViewer):

// NuGet: Install-Package PdfiumViewer
//        Install-Package PdfiumViewer.Native.x86.v8-xfa
//        Install-Package PdfiumViewer.Native.x86_64.v8-xfa
using PdfiumViewer;
using System;
using System.Text;

string pdfPath = "document.pdf";

// PdfiumViewerexposes page-level text extraction via
// PdfDocument.GetPdfText(int page). It returns raw page text only —
// no layout, no per-word coordinates, no OCR for image-only pages.
using (var document = PdfDocument.Load(pdfPath))
{
    int pageCount = document.PageCount;
    Console.WriteLine($"Total pages: {pageCount}");

    var sb = new StringBuilder();
    for (int i = 0; i < pageCount; i++)
    {
        string pageText = document.GetPdfText(i);
        sb.AppendLine($"--- Page {i + 1} ---");
        sb.AppendLine(pageText);
    }

    Console.WriteLine(sb.ToString());
}

// NuGet: Install-Package PdfiumViewer
//        Install-Package PdfiumViewer.Native.x86.v8-xfa
//        Install-Package PdfiumViewer.Native.x86_64.v8-xfa
using PdfiumViewer;
using System;
using System.Text;

string pdfPath = "document.pdf";

// PdfiumViewerexposes page-level text extraction via
// PdfDocument.GetPdfText(int page). It returns raw page text only —
// no layout, no per-word coordinates, no OCR for image-only pages.
using (var document = PdfDocument.Load(pdfPath))
{
    int pageCount = document.PageCount;
    Console.WriteLine($"Total pages: {pageCount}");

    var sb = new StringBuilder();
    for (int i = 0; i < pageCount; i++)
    {
        string pageText = document.GetPdfText(i);
        sb.AppendLine($"--- Page {i + 1} ---");
        sb.AppendLine(pageText);
    }

    Console.WriteLine(sb.ToString());
}

Imports PdfiumViewer
Imports System
Imports System.Text

Dim pdfPath As String = "document.pdf"

' PdfiumViewer exposes page-level text extraction via
' PdfDocument.GetPdfText(int page). It returns raw page text only —
' no layout, no per-word coordinates, no OCR for image-only pages.
Using document As PdfDocument = PdfDocument.Load(pdfPath)
    Dim pageCount As Integer = document.PageCount
    Console.WriteLine($"Total pages: {pageCount}")

    Dim sb As New StringBuilder()
    For i As Integer = 0 To pageCount - 1
        Dim pageText As String = document.GetPdfText(i)
        sb.AppendLine($"--- Page {i + 1} ---")
        sb.AppendLine(pageText)
    Next

    Console.WriteLine(sb.ToString())
End Using

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

string pdfPath = "document.pdf";

// Open and extract text from PDF
PdfDocument pdf = PdfDocument.FromFile(pdfPath);

// Extract text from all pages
string allText = pdf.ExtractAllText();
Console.WriteLine("Extracted Text:");
Console.WriteLine(allText);

// Extract text from specific page
string pageText = pdf.ExtractTextFromPage(0);
Console.WriteLine($"\nFirst page text: {pageText}");

Console.WriteLine($"\nTotal pages: {pdf.PageCount}");

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

string pdfPath = "document.pdf";

// Open and extract text from PDF
PdfDocument pdf = PdfDocument.FromFile(pdfPath);

// Extract text from all pages
string allText = pdf.ExtractAllText();
Console.WriteLine("Extracted Text:");
Console.WriteLine(allText);

// Extract text from specific page
string pageText = pdf.ExtractTextFromPage(0);
Console.WriteLine($"\nFirst page text: {pageText}");

Console.WriteLine($"\nTotal pages: {pdf.PageCount}");

Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim pdfPath As String = "document.pdf"

        ' Open and extract text from PDF
        Dim pdf As PdfDocument = PdfDocument.FromFile(pdfPath)

        ' Extract text from all pages
        Dim allText As String = pdf.ExtractAllText()
        Console.WriteLine("Extracted Text:")
        Console.WriteLine(allText)

        ' Extract text from specific page
        Dim pageText As String = pdf.ExtractTextFromPage(0)
        Console.WriteLine(vbCrLf & "First page text: " & pageText)

        Console.WriteLine(vbCrLf & "Total pages: " & pdf.PageCount)
    End Sub
End Module

Die Text-API von PdfiumViewerist PdfDocument.GetPdfText(int page) – nur raw text auf Seitenebene, keine Layout-Rekonstruktion, keine Wortkoordinaten und kein OCR-Fallback für nur-Bild-PDFs. Alles über einen reines Textabzug hinaus erfordert entweder benutzerdefinierte Layout-Heuristiken oder eine andere Bibliothek.

IronPDF bietet gesamte Dokumentenextraktion über ExtractAllText() und Seitenauszüge über ExtractTextFromPage(index) (oder pdf.Pages[index].Text). Weitere Optionen finden Sie in der Dokumentation zur Textextraktion .

Beispiel 2: Konvertierung von HTML in PDF

Vor (PdfiumViewer):

// NuGet: Install-Package PdfiumViewer
using PdfiumViewer;
using System;

// PdfiumViewerwraps Google's PDFium — a renderer, not a generator.
// PDFium does not parse HTML, so PdfiumViewerhas no HTML-to-PDF path.
// To produce a PDF from HTML you need a separate generator (wkhtmltopdf,
// IronPDF, PuppeteerSharp, etc.), then load the result with PdfiumViewer
// for display or rasterization.

string htmlContent = "<h1>Hello World</h1><p>This is a test document.</p>";

// Pretend "output.pdf" was produced by another tool — load and render it.
string existingPdfPath = "output.pdf";
using (var document = PdfDocument.Load(existingPdfPath))
{
    Console.WriteLine($"Loaded PDF with {document.PageCount} page(s).");

    // PdfDocument.Render(int page, float dpiX, float dpiY, bool forPrinting)
    var image = document.Render(0, 300, 300, true);
    Console.WriteLine("Rendered page 1 at 300 DPI.");
}

// NuGet: Install-Package PdfiumViewer
using PdfiumViewer;
using System;

// PdfiumViewerwraps Google's PDFium — a renderer, not a generator.
// PDFium does not parse HTML, so PdfiumViewerhas no HTML-to-PDF path.
// To produce a PDF from HTML you need a separate generator (wkhtmltopdf,
// IronPDF, PuppeteerSharp, etc.), then load the result with PdfiumViewer
// for display or rasterization.

string htmlContent = "<h1>Hello World</h1><p>This is a test document.</p>";

// Pretend "output.pdf" was produced by another tool — load and render it.
string existingPdfPath = "output.pdf";
using (var document = PdfDocument.Load(existingPdfPath))
{
    Console.WriteLine($"Loaded PDF with {document.PageCount} page(s).");

    // PdfDocument.Render(int page, float dpiX, float dpiY, bool forPrinting)
    var image = document.Render(0, 300, 300, true);
    Console.WriteLine("Rendered page 1 at 300 DPI.");
}

Imports PdfiumViewer
Imports System

' PdfiumViewer wraps Google's PDFium — a renderer, not a generator.
' PDFium does not parse HTML, so PdfiumViewer has no HTML-to-PDF path.
' To produce a PDF from HTML you need a separate generator (wkhtmltopdf,
' IronPDF, PuppeteerSharp, etc.), then load the result with PdfiumViewer
' for display or rasterization.

Dim htmlContent As String = "<h1>Hello World</h1><p>This is a test document.</p>"

' Pretend "output.pdf" was produced by another tool — load and render it.
Dim existingPdfPath As String = "output.pdf"
Using document As PdfDocument = PdfDocument.Load(existingPdfPath)
    Console.WriteLine($"Loaded PDF with {document.PageCount} page(s).")

    ' PdfDocument.Render(int page, float dpiX, float dpiY, bool forPrinting)
    Dim image = document.Render(0, 300, 300, True)
    Console.WriteLine("Rendered page 1 at 300 DPI.")
End Using

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

string htmlContent = "<h1>Hello World</h1><p>This is a test document.</p>";

// Create a PDF from HTML string
var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Save the PDF
pdf.SaveAs("output.pdf");

Console.WriteLine("PDF created successfully!");

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

string htmlContent = "<h1>Hello World</h1><p>This is a test document.</p>";

// Create a PDF from HTML string
var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Save the PDF
pdf.SaveAs("output.pdf");

Console.WriteLine("PDF created successfully!");

Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim htmlContent As String = "<h1>Hello World</h1><p>This is a test document.</p>"

        ' Create a PDF from HTML string
        Dim renderer As New ChromePdfRenderer()
        Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

        ' Save the PDF
        pdf.SaveAs("output.pdf")

        Console.WriteLine("PDF created successfully!")
    End Sub
End Module

Dies ist die größte Fähigkeitslücke. PDFium parsiert kein HTML, also hat PdfiumViewerkeinen HTML-zu-PDF-Pfad – Sie würden das PDF zuerst mit einem anderen Tool erstellen und es dann mit PdfiumVieweranzeigen oder rasterisieren.

IronPDF bietet native HTML-zu-PDF-Konvertierung durch ChromePdfRenderer, das intern eine Chromium-Engine für HTML-, CSS- und JavaScript-Rendering verwendet. RenderHtmlAsPdf() konvertiert HTML-Strings, RenderUrlAsPdf() erfasst URLs, und RenderHtmlFileAsPdf() liest HTML-Dateien. Umfassende Beispiele finden Sie in der HTML to PDF Dokumentation.

Beispiel 3: Konvertierung von PDF in Bilder

Vor (PdfiumViewer):

// NuGet: Install-Package PdfiumViewer
using PdfiumViewer;
using System;
using System.Drawing;
using System.Drawing.Imaging;

string pdfPath = "document.pdf";
string outputImage = "page1.png";

// PDFiumViewer excels at rendering PDFs to images
using (var document = PdfDocument.Load(pdfPath))
{
    // Render first page at 300 DPI
    int dpi = 300;
    using (var image = document.Render(0, dpi, dpi, true))
    {
        // Save as PNG
        image.Save(outputImage, ImageFormat.Png);
        Console.WriteLine($"Page rendered to {outputImage}");
    }

    // Render all pages
    for (int i = 0; i < document.PageCount; i++)
    {
        using (var pageImage = document.Render(i, 150, 150, true))
        {
            pageImage.Save($"page_{i + 1}.png", ImageFormat.Png);
        }
    }
}

// NuGet: Install-Package PdfiumViewer
using PdfiumViewer;
using System;
using System.Drawing;
using System.Drawing.Imaging;

string pdfPath = "document.pdf";
string outputImage = "page1.png";

// PDFiumViewer excels at rendering PDFs to images
using (var document = PdfDocument.Load(pdfPath))
{
    // Render first page at 300 DPI
    int dpi = 300;
    using (var image = document.Render(0, dpi, dpi, true))
    {
        // Save as PNG
        image.Save(outputImage, ImageFormat.Png);
        Console.WriteLine($"Page rendered to {outputImage}");
    }

    // Render all pages
    for (int i = 0; i < document.PageCount; i++)
    {
        using (var pageImage = document.Render(i, 150, 150, true))
        {
            pageImage.Save($"page_{i + 1}.png", ImageFormat.Png);
        }
    }
}

Imports PdfiumViewer
Imports System
Imports System.Drawing
Imports System.Drawing.Imaging

Module Module1
    Sub Main()
        Dim pdfPath As String = "document.pdf"
        Dim outputImage As String = "page1.png"

        ' PDFiumViewer excels at rendering PDFs to images
        Using document = PdfDocument.Load(pdfPath)
            ' Render first page at 300 DPI
            Dim dpi As Integer = 300
            Using image = document.Render(0, dpi, dpi, True)
                ' Save as PNG
                image.Save(outputImage, ImageFormat.Png)
                Console.WriteLine($"Page rendered to {outputImage}")
            End Using

            ' Render all pages
            For i As Integer = 0 To document.PageCount - 1
                Using pageImage = document.Render(i, 150, 150, True)
                    pageImage.Save($"page_{i + 1}.png", ImageFormat.Png)
                End Using
            Next
        End Using
    End Sub
End Module

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Linq;

string pdfPath = "document.pdf";
string outputImage = "page1.png";

// Open PDF and convert to images
PdfDocument pdf = PdfDocument.FromFile(pdfPath);

// Convert first page to image
var firstPageImage = pdf.ToBitmap(0);
firstPageImage[0].Save(outputImage);
Console.WriteLine($"Page rendered to {outputImage}");

// Convert all pages to images
var allPageImages = pdf.ToBitmap();
for (int i = 0; i < allPageImages.Length; i++)
{
    allPageImages[i].Save($"page_{i + 1}.png");
    Console.WriteLine($"Saved page {i + 1}");
}

Console.WriteLine($"Total pages converted: {pdf.PageCount}");

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Linq;

string pdfPath = "document.pdf";
string outputImage = "page1.png";

// Open PDF and convert to images
PdfDocument pdf = PdfDocument.FromFile(pdfPath);

// Convert first page to image
var firstPageImage = pdf.ToBitmap(0);
firstPageImage[0].Save(outputImage);
Console.WriteLine($"Page rendered to {outputImage}");

// Convert all pages to images
var allPageImages = pdf.ToBitmap();
for (int i = 0; i < allPageImages.Length; i++)
{
    allPageImages[i].Save($"page_{i + 1}.png");
    Console.WriteLine($"Saved page {i + 1}");
}

Console.WriteLine($"Total pages converted: {pdf.PageCount}");

Imports IronPdf
Imports System
Imports System.Linq

Module Module1
    Sub Main()
        Dim pdfPath As String = "document.pdf"
        Dim outputImage As String = "page1.png"

        ' Open PDF and convert to images
        Dim pdf As PdfDocument = PdfDocument.FromFile(pdfPath)

        ' Convert first page to image
        Dim firstPageImage = pdf.ToBitmap(0)
        firstPageImage(0).Save(outputImage)
        Console.WriteLine($"Page rendered to {outputImage}")

        ' Convert all pages to images
        Dim allPageImages = pdf.ToBitmap()
        For i As Integer = 0 To allPageImages.Length - 1
            allPageImages(i).Save($"page_{i + 1}.png")
            Console.WriteLine($"Saved page {i + 1}")
        Next

        Console.WriteLine($"Total pages converted: {pdf.PageCount}")
    End Sub
End Module

Dies ist ein Bereich, in dem sich PdfiumViewerauszeichnet - die Umwandlung von PDF in Bilder ist seine Hauptstärke. Beide Bibliotheken bewältigen diese Aufgabe effektiv, aber mit unterschiedlichen Mustern.

PdfiumViewer verwendet document.Render(pageIndex, dpiX, dpiY, forPrinting) mit verschachtelten using Anweisungen für die ordnungsgemäße Entsorgung. Sie müssen System.Drawing und System.Drawing.Imaging für die ImageFormat-Enum importieren.

IronPDF verwendet pdf.ToBitmap(pageIndex), das ein Bitmap-Array zurückgibt. Das Muster ist einfacher, ohne verschachtelte Entsorgungsanforderungen. Für Batch-Operationen gibt ToBitmap() ohne Parameter alle Seiten zurück. Sie können auch RasterizeToImageFiles() für direkten Dateiausgabe verwenden. Weitere Rendering-Optionen finden Sie in der PDF zu Bild Dokumentation.

Vor (PdfiumViewer) - Komplexe Bereitstellung

MyApp/
├── bin/
│ ├── MyApp.dll
│ ├── PdfiumViewer.dll
│ ├── x86/
│ │ └── pdfium.dll
│ └── x64/
│ └── pdfium.dll

Nach (IronPDF) - Saubere Bereitstellung

MyApp/
├── bin/
│ ├── MyApp.dll
│ └── IronPDF.dll # Alles enthalten

Native binäre Referenzen entfernen

# Delete native PDFium binaries
rm -rf x86/x64/runtimes/

# Remove from .csproj native package references
# <PackageReference Include="PdfiumViewer.Native.x86.v8-xfa" />
# <PackageReference Include="PdfiumViewer.Native.x64.v8-xfa" />

# Delete native PDFium binaries
rm -rf x86/x64/runtimes/

# Remove from .csproj native package references
# <PackageReference Include="PdfiumViewer.Native.x86.v8-xfa" />
# <PackageReference Include="PdfiumViewer.Native.x64.v8-xfa" />

Keine eingebaute Viewer-Steuerung

IronPDF ist Backend-orientiert und enthält keine visuelle PDF-Viewer-Steuerung:

// PdfiumViewer: Built-in viewer control
pdfViewer.Document = document;

// IronPDF: Use external viewer or web-based approach
pdf.SaveAs(tempPath);
Process.Start(new ProcessStartInfo(tempPath) { UseShellExecute = true });

// PdfiumViewer: Built-in viewer control
pdfViewer.Document = document;

// IronPDF: Use external viewer or web-based approach
pdf.SaveAs(tempPath);
Process.Start(new ProcessStartInfo(tempPath) { UseShellExecute = true });

' PdfiumViewer: Built-in viewer control
pdfViewer.Document = document

' IronPDF: Use external viewer or web-based approach
pdf.SaveAs(tempPath)
Process.Start(New ProcessStartInfo(tempPath) With {.UseShellExecute = True})

Für Ansichtsanforderungen sollten Sie erwägen, Process.Start() zu verwenden, um im Standard-PDF-Viewer zu öffnen, ein WebBrowser-Steuer mit dem PDF-Pfad oder Drittanbieter-Viewer-Steuerelemente wie Syncfusion, DevExpress oder Telerik.

Änderung der Methode zum Laden von Dokumenten

// PdfiumViewer
PdfDocument.Load(path)

// IronPDF
PdfDocument.FromFile(path)

// PdfiumViewer
PdfDocument.Load(path)

// IronPDF
PdfDocument.FromFile(path)

' PdfiumViewer
PdfDocument.Load(path)

' IronPDF
PdfDocument.FromFile(path)

Methodenänderung speichern

// PdfiumViewer
document.Save(path)

// IronPDF
pdf.SaveAs(path)

// PdfiumViewer
document.Save(path)

// IronPDF
pdf.SaveAs(path)

Rendering-Methode ändern

// PdfiumViewer: Returns image with nested using
using (var image = document.Render(0, 150, 150, true))
{
    image.Save("page.png", ImageFormat.Png);
}

// IronPDF: Returns bitmap array
var images = pdf.ToBitmap(0);
images[0].Save("page.png");

// PdfiumViewer: Returns image with nested using
using (var image = document.Render(0, 150, 150, true))
{
    image.Save("page.png", ImageFormat.Png);
}

// IronPDF: Returns bitmap array
var images = pdf.ToBitmap(0);
images[0].Save("page.png");

Imports System.Drawing.Imaging

' PdfiumViewer: Returns image with nested using
Using image = document.Render(0, 150, 150, True)
    image.Save("page.png", ImageFormat.Png)
End Using

' IronPDF: Returns bitmap array
Dim images = pdf.ToBitmap(0)
images(0).Save("page.png")

Seitengröße Zugriff ändern

// PdfiumViewer
var size = document.PageSizes[index];
Console.WriteLine($"{size.Width} x {size.Height}");

// IronPDF
var page = pdf.Pages[index];
Console.WriteLine($"{page.Width} x {page.Height}");

// PdfiumViewer
var size = document.PageSizes[index];
Console.WriteLine($"{size.Width} x {size.Height}");

// IronPDF
var page = pdf.Pages[index];
Console.WriteLine($"{page.Width} x {page.Height}");

' PdfiumViewer
Dim size = document.PageSizes(index)
Console.WriteLine($"{size.Width} x {size.Height}")

' IronPDF
Dim page = pdf.Pages(index)
Console.WriteLine($"{page.Width} x {page.Height}")

Vor der Migration

• Alle Verwendungen von PdfiumViewerim Quellcode identifizieren
• WinForms-Auflistung mit dem PdfViewer-Steuerelement
• Dokumentieren Sie die aktuellen DPI-Einstellungen für die Darstellung
• Auf native Binärreferenzen prüfen
• Nutzung der Druckfunktionen ermitteln
• Strategie zur Ablösung der Planbetrachtersteuerung -IronPDF-Lizenzschlüssel erhalten

Paketänderungen

• Entfernen Sie das PdfiumViewer NuGet-Paket
• Entfernen Sie das PdfiumViewer.Native.x86.v8-xfa-Paket
• Entfernen Sie das PdfiumViewer.Native.x86_64.v8-xfa-Paket
• Löschen Sie die nativen pdfium.dll-Binärdateien aus den Ordnern x86/und x64/.
• Installieren Sie das IronPdf NuGet-Paket: dotnet add package IronPdf

Code-Änderungen

• Lizenzschlüsselkonfiguration beim Start hinzufügen
• Ersetzen Sie PdfDocument.Load() durch PdfDocument.FromFile()
• Ersetzen Sie document.Save() durch pdf.SaveAs()
• Ersetzen Sie document.Render() mit pdf.ToBitmap() oder RasterizeToImageFiles()
• Ersetzen Sie document.PageSizes[i] mit pdf.Pages[i].Width/Height
• Ersetzen Sie das PdfViewer-Steuerelement durch einen externen Viewer oder Process.Start().
• Neue Funktionen hinzufügen (Textextraktion, HTML zu PDF usw.).

Nach der Migration

• Test der Ausgabequalität des Renderings
• Testdruckfunktion
• Test auf den Zielplattformen
• Neue Funktionen hinzufügen (HTML zu PDF, Zusammenführen, Wasserzeichen, Sicherheit)
• Dokumentation aktualisieren