Durch die Migration von PDFsharpzu IronPDF wandeln Sie Ihren PDF-Generierungs-Workflow vom manuellen, koordinatenbasierten Zeichnen zur modernen HTML/CSS-Vorlagenerstellung. Diese Anleitung bietet einen schrittweisen Migrationsweg, der das GDI+-Stil-Positionieren durch Webtechnologien ersetzt, die Entwicklungszeit reduziert und die PDF-Generierung wartbar durch Standard-HTML/CSS-Kenntnisse macht.
PDFsharp ist eine Low-Level-PDF-Erstellungsbibliothek, die Entwicklern ermöglicht, PDF-Dokumente programmatisch zu erzeugen. Veröffentlicht unter der MIT-Lizenz und gewartet vom PDFsharp-Team (ursprünglich empira Software GmbH), zielt PDFsharp6.x auf .NET 8/9/10 und .NET Standard 2.0 ab und läuft plattformübergreifend auf Windows, Linux und macOS über den Core-Build. PDFsharpfungiert hauptsächlich als Werkzeug zum Zeichnen und Erstellen von PDFs von Grund auf mit einer GDI+-Stil-API, die je nach Projektcharakter sowohl vorteilhaft als auch einschränkend sein kann.
PDFsharp wird manchmal fälschlicherweise als HTML-zu-PDF-Konverter angesehen, was es nicht ist. Der Zweck ist ausschließlich auf die programmatische Erstellung von PDF-Dokumenten ausgerichtet. Während es ein Community-Add-On, HtmlRenderer.PdfSharp (von ArthurHub), gibt, das HTML-Darstellungsfähigkeiten bieten soll, deckt es nur HTML 4.01 / CSS-Level 2 ab — keine modernen CSS-Features wie Flexbox, Grid oder JavaScript.
Der GDI+-Ansatz von PDFsharpbedeutet, dass Sie:
Die Architektur von PDFsharperfordert ein tiefes Verständnis der Positionierung mit Koordinaten, was oft Herausforderungen bei der Erstellung komplexer Layouts darstellt.
| Feature | PDFsharp | IronPDF |
|---|---|---|
| Lizenz | MIT (kostenlos) | Kommerziell |
| HTML zu PDF Unterstützung | Nein | Ja (HTML5/CSS3-Unterstützung) |
| Moderne CSS-Unterstützung | Nein (HTML 4.01 / CSS 2 über HtmlRenderer-Add-On) | Ja (Vollständig CSS3) |
| Dokumentenerstellung | Koordinatenbasiertes Zeichnen | HTML/CSS-Vorlagen |
| Layout-System | Manuelle X,Y-Positionierung | CSS Flow/Flexbox/Grid |
| Seitenumbrüche | Manuelle Berechnung | Automatische + CSS-Steuerung |
| Tabellen | Zellen einzeln zeichnen | HTML <table> |
| Styling | Code-basierte Schriftarten/Farben | CSS-Stylesheets |
| Dokument API | Low-Level (Erfordert Koordinaten) | High-Level (Vereinfachte API) |
| Aktualisierungen | Aktiv (6.x Linie) | Regelmäßig |
IronPDF eignet sich hervorragend für Szenarien, in denen HTML-Dokumente originalgetreu in PDFs konvertiert werden müssen. Diese .NET-Bibliothek unterstützt HTML5 und CSS3, so dass moderne Webstandards eingehalten werden. Dank der nativen HTML-zu-PDF-Funktionen können Entwickler vorhandene Webinhalte oder mit modernen Webtools erstellte Vorlagen nutzen.
Für Teams auf modernem .NET bietet IronPDF einen Ansatz, der Koordinatenberechnungen eliminiert und Webentwicklungskompetenzen nutzt.
# Remove PDFsharp(official PDFsharp-Team package IDs; case-sensitive on case-sensitive feeds)
dotnet remove package PDFsharp
# dotnet remove package PDFsharp-WPF # if you used the WPF build
# dotnet remove package PDFsharp-GDI # if you used the GDI build
# dotnet remove package PDFsharp-MigraDoc # if you used MigraDoc on top
# dotnet remove package PdfSharpCore # community .NET Standard port
# Add IronPDF
dotnet add package IronPdf// 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"# Find all PDFsharpusages in your codebase
grep -r "PdfSharp\|XGraphics\|XFont\|XBrush\|XPen" --include="*.cs" .// Before: PDFsharp
using PdfSharp.Pdf;
using PdfSharp.Drawing;
using PdfSharp.Pdf.IO;
// After: IronPDF
using IronPdf;
using IronPdf.Editing;Imports IronPdf
Imports IronPdf.Editing| PDFsharp API | IronPDF API |
|---|---|
new PdfDocument() | ChromePdfRenderer.RenderHtmlAsPdf() |
document.AddPage() | Automatisch |
XGraphics.FromPdfPage() | Nicht erforderlich |
XGraphics.DrawString() | HTML <p>, <h1>, usw. |
XGraphics.DrawImage() | HTML <img> Tag |
XFont | CSS font-family, font-size |
XBrush, XPen | CSS-Farben/Rahmen |
document.Save() | pdf.SaveAs() |
PdfReader.Open() | PdfDocument.FromFile() |
Before (PDFsharp):
// NuGet: Install-Package PDFsharp (official PDFsharp-Team package, MIT)
// PDFsharpdoes NOT support HTML-to-PDF natively. The community add-on
// HtmlRenderer.PdfSharp covers HTML 4.01 / CSS level 2 only (no flexbox, grid, JS).
using PdfSharp.Pdf;
using PdfSharp.Drawing;
using System;
class Program
{
static void Main()
{
// PDFsharpdoes not have built-in HTML zu PDFconversion
// You need to manually parse HTML and render content
PdfDocument document = new PdfDocument();
PdfPage page = document.AddPage();
XGraphics gfx = XGraphics.FromPdfPage(page);
XFont font = new XFont("Arial", 12);
// Handbuch text rendering (no HTML support)
gfx.DrawString("Hello from PDFsharp", font, XBrushes.Black,
new XRect(0, 0, page.Width, page.Height),
XStringFormats.TopLeft);
document.Save("output.pdf");
}
}Nach (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main()
{
//IronPDF has native HTML zu PDFrendering
var renderer = new ChromePdfRenderer();
string html = "<h1>Hello from IronPDF</h1><p>Easy HTML zu PDFconversion</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
}
}Dieses Beispiel verdeutlicht den größten Unterschied zwischen den beiden Bibliotheken. PDFsharpbietet keine eingebaute HTML zu PDF-Konvertierung—Sie müssen manuell ein PdfDocument erstellen, ein PdfPage hinzufügen, ein XGraphics Objekt erhalten, ein XFont erstellen und DrawString() mit XRect Koordinaten verwenden.
IronPDF bietet natives HTML zu PDF-Rendering durch ChromePdfRenderer. Die RenderHtmlAsPdf() Methode akzeptiert HTML-Strings und konvertiert sie intern mithilfe eines Chromium-Engines.IronPDF konvertiert HTML-Dateien mühelos in PDF, wobei alle in HTML5 und CSS3 definierten Stile beibehalten werden und keine Koordinatenberechnungen erforderlich sind. Umfassende Beispiele finden Sie in der HTML to PDF Dokumentation.
Before (PDFsharp):
// NuGet: Install-Package PDFsharp (official PDFsharp-Team package, MIT)
using PdfSharp.Pdf;
using PdfSharp.Pdf.IO;
using PdfSharp.Drawing;
using System;
class Program
{
static void Main()
{
// Open existing PDF
PdfDocument document = PdfReader.Open("existing.pdf", PdfDocumentOpenMode.Modify);
PdfPage page = document.Pages[0];
// Get graphics object
XGraphics gfx = XGraphics.FromPdfPage(page);
// Note: in PDFsharp6.x, XFontStyle was renamed to XFontStyleEx
XFont font = new XFont("Arial", 20, XFontStyleEx.Bold);
// Draw text at specific position
gfx.DrawString("Watermark Text", font, XBrushes.Red,
new XPoint(200, 400));
document.Save("modified.pdf");
}
}Nach (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;
using System;
class Program
{
static void Main()
{
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Open existing PDF
var pdf = PdfDocument.FromFile("existing.pdf");
// Add text stamp/watermark
var textStamper = new TextStamper()
{
Text = "Watermark Text",
FontSize = 20,
FontFamily = "Arial",
IsBold = true,
FontColor = IronSoftware.Drawing.Color.Red,
VerticalAlignment = VerticalAlignment.Middle,
HorizontalAlignment = HorizontalAlignment.Center
};
pdf.ApplyStamp(textStamper);
pdf.SaveAs("modified.pdf");
}
}PDFsharp erfordert das Öffnen des PDF mit PdfReader.Open(), das Festlegen von PdfDocumentOpenMode.Modify, den Zugriff auf eine Seite, das Erstellen eines XGraphics Objekts, das Erstellen eines XFont mit Stil und das Verwenden von DrawString() mit einem XPoint, das genaue X,Y-Koordinaten (200, 400) angibt.
IronPDF vereinfacht dies mit PdfDocument.FromFile(), einem TextStamper Objekt mit deklarativen Eigenschaften (Text, FontSize, FontFamily, IsBold, FontColor, VerticalAlignment, HorizontalAlignment) und ApplyStamp(). Es sind keine Koordinatenberechnungen erforderlich - geben Sie einfach die Ausrichtung an und IronPDF übernimmt die Positionierung. Beachten Sie, dass das IronPdf.Editing-Namespace für die Stempelfunktionalität erforderlich ist.
Before (PDFsharp):
// NuGet: Install-Package PDFsharp (official PDFsharp-Team package, MIT)
using PdfSharp.Pdf;
using PdfSharp.Drawing;
using System;
class Program
{
static void Main()
{
// Create new PDF document
PdfDocument document = new PdfDocument();
PdfPage page = document.AddPage();
XGraphics gfx = XGraphics.FromPdfPage(page);
// Load and draw image
XImage image = XImage.FromFile("image.jpg");
// Calculate size to fit page
double width = 200;
double height = 200;
gfx.DrawImage(image, 50, 50, width, height);
// Add text
XFont font = new XFont("Arial", 16);
gfx.DrawString("Image in PDF", font, XBrushes.Black,
new XPoint(50, 270));
document.Save("output.pdf");
}
}Nach (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main()
{
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Create PDF from HTML with image
var renderer = new ChromePdfRenderer();
string html = @"
<h1>Image in PDF</h1>
<img src='image.jpg' style='width:200px; height:200px;' />
<p>Easy image embedding with HTML</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Alternative: Add image to existing PDF
var existingPdf = new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Document</h1>");
var imageStamper = new IronPdf.Editing.ImageStamper(new Uri("image.jpg"))
{
VerticalAlignment = IronPdf.Editing.VerticalAlignment.Top
};
existingPdf.ApplyStamp(imageStamper);
}
}PDFsharp erfordert das Erstellen eines neuen PdfDocument, das Hinzufügen eines PdfPage, das Erhalten von XGraphics, das Laden eines XImage aus Datei, das Berechnen von Breite und Höhe, die Verwendung von DrawImage() mit genauen Koordinaten (50, 50, 200, 200), dann das separate Hinzufügen von Text mit DrawString().
IronPDF verwendet standardmäßiges HTML mit einem <img>-Tag und CSS-Styling (style='width:200px; Höhe: 200px;'). Keine Koordinatenberechnungen erforderlich - das Layout wird von CSS übernommen.IronPDF bietet auch ImageStamper zum Hinzufügen von Bildern zu bestehenden PDFs mit deklarativen Ausrichtungseigenschaften. Erfahren Sie mehr in unseren Tutorials.
Die wichtigste Änderung ist der Wechsel vom koordinatenbasierten Zeichnen zu HTML/CSS:
// PDFsharp: manual positioning
gfx.DrawString("Invoice", titleFont, XBrushes.Black, new XPoint(50, 50));
gfx.DrawString("Customer: John", bodyFont, XBrushes.Black, new XPoint(50, 80));
// IronPDF: let CSS handle layout
var html = @"
<div style='padding: 50px;'>
<h1>Invoice</h1>
<p>Customer: John</p>
</div>";
var pdf = renderer.RenderHtmlAsPdf(html);Imports PdfSharp.Drawing
Imports IronPdf
' PDFsharp: manual positioning
gfx.DrawString("Invoice", titleFont, XBrushes.Black, New XPoint(50, 50))
gfx.DrawString("Customer: John", bodyFont, XBrushes.Black, New XPoint(50, 80))
' IronPDF: let CSS handle layout
Dim html As String = "
<div style='padding: 50px;'>
<h1>Invoice</h1>
<p>Customer: John</p>
</div>"
Dim pdf = renderer.RenderHtmlAsPdf(html)// PDFsharp: XFont objects (PDFsharp 6.x renamed XFontStyle to XFontStyleEx)
var titleFont = new XFont("Arial", 24, XFontStyleEx.Bold);
var bodyFont = new XFont("Times New Roman", 12);
// IronPDF: CSS font properties
var html = @"
<style>
h1 { font-family: Arial, sans-serif; font-size: 24px; font-weight: bold; }
p { font-family: 'Times New Roman', serif; font-size: 12px; }
</style>";' PDFsharp: XFont objects (PDFsharp 6.x renamed XFontStyle to XFontStyleEx)
Dim titleFont As New XFont("Arial", 24, XFontStyleEx.Bold)
Dim bodyFont As New XFont("Times New Roman", 12)
' IronPDF: CSS font properties
Dim html As String = "
<style>
h1 { font-family: Arial, sans-serif; font-size: 24px; font-weight: bold; }
p { font-family: 'Times New Roman', serif; font-size: 12px; }
</style>"// PDFsharp: PdfReader.Open()
PdfDocument document = PdfReader.Open("existing.pdf", PdfDocumentOpenMode.Modify);
// IronPDF: PdfDocument.FromFile()
var pdf = PdfDocument.FromFile("existing.pdf");Imports PdfSharp.Pdf
Imports PdfSharp.Pdf.IO
Imports IronPdf
' PDFsharp: PdfReader.Open()
Dim document As PdfDocument = PdfReader.Open("existing.pdf", PdfDocumentOpenMode.Modify)
' IronPDF: PdfDocument.FromFile()
Dim pdf As PdfDocument = PdfDocument.FromFile("existing.pdf")// PDFsharp: document.Save()
document.Save("output.pdf");
// IronPDF: pdf.SaveAs()
pdf.SaveAs("output.pdf");' PDFsharp: document.Save()
document.Save("output.pdf")
' IronPDF: pdf.SaveAs()
pdf.SaveAs("output.pdf")// PDFsharp: document.Pages[0]
PdfPage page = document.Pages[0];
// IronPDF: Automatischpage handling or pdf.Pages[0]
// Pages are created automatically from HTML contentNach der Migration zu IronPDF erhalten Sie Fähigkeiten, die PDFsharpnicht bieten kann:
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Modern Web Content</h1>");Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Modern Web Content</h1>")var pdf = renderer.RenderUrlAsPdf("https://example.com");Dim pdf = renderer.RenderUrlAsPdf("https://example.com")var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")
Dim merged = PdfDocument.Merge(pdf1, pdf2)pdf.ApplyWatermark("<h2 style='color:red;'>CONFIDENTIAL</h2>");pdf.ApplyWatermark("<h2 style='color:red;'>CONFIDENTIAL</h2>")| Feature | PDFsharp | IronPDF |
|---|---|---|
| Koordinatenbasiertes Zeichnen | ✓ | ✗(HTML verwenden) |
| HTML zu PDF | ✗ | ✓ |
| CSS3-Unterstützung | ✗ | ✓ |
| Flexbox/Grid-Layout | ✗ | ✓ |
| Textstempel | Handbuch XGraphics | TextStamper |
| Bildstempel | Handbuch XImage | ImageStamper |
| PDFs zusammenführen | Handbuch | ✓ |
| URL zu PDF | ✗ | ✓ |
| Modernes Web-Rendering | ✗ | Chromium-Engine |
| Automatische Seitenumbrüche | ✗ | ✓ |
PDFsharp NuGet-Paket (offizielles PDFsharp-Team-Paket)PDFsharp-WPF, PDFsharp-GDI oder PDFsharp-MigraDoc, falls verwendetPdfSharpCore, wenn Sie den Community .NET Standard-Port verwendet habenIronPdf NuGet-Paket: dotnet add package IronPdfusing PdfSharp.Pdf; → using IronPdf;)using IronPdf.Editing; für die Stempelfunktionalität hinzuXFont durch CSS-SchriftarteneigenschaftenXPen durch CSS-Farben/RänderXGraphics.DrawString() durch HTML-TextelementeXGraphics.DrawImage() durch HTML-<img>-TagsPdfReader.Open() durch PdfDocument.FromFile()document.Save() durch pdf.SaveAs()
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.
