PRODUKT-VERGLEICHE

Ein Vergleich zwischen IronPDF und PDFSharpCore

Veröffentlicht 6. März 2024

Teilen Sie:

Die Erstellung und Verwaltung von PDF-Dateien ist eine häufige Anforderung in der Softwareentwicklung. Entwickler benötigen häufig Bibliotheken, die als NuGet-Pakete verfügbar sind und mit denen sie mühelos PDFs erzeugen, bearbeiten und manipulieren können. IronPDF und PDFSharpCore sind zwei bekannte Bibliotheken im Ökosystem der .NET-Sprache, die diesen Zweck erfüllen. Dieser Artikel, der für Visual Studio-Benutzer relevant ist, befasst sich mit beiden, hebt ihre Funktionen und Unterschiede hervor und zeigt, wie sie in .NET-Projekten verwendet werden können.

Einführung in IronPDF und PDFSharpCore

IronPDF ist eine umfassende .NET-Bibliothek, die Entwicklern die mühelose Erstellung, Bearbeitung und Konvertierung von PDF-Dokumenten ermöglicht. Es bietet eine breite Palette von Funktionen zum Erstellen, Bearbeiten und Konvertieren solcher Dokumente. IronPDF unterstützt .NET Core und Frameworks und ist damit vielseitig einsetzbar für verschiedene Anwendungen, einschließlich Web und Desktop.

die PDFSharpCore**-Bibliothek ist eine Teilportierung der ursprünglichen PDFsharp-Bibliothek. Es zielt auf .NET Core und zusätzlich auf die MigraDoc Foundation ab und konzentriert sich auf die Erstellung und Verarbeitung von PDF-Dokumenten, ohne auf Windows-Bibliotheken angewiesen zu sein. Dadurch eignet es sich für plattformübergreifende Projekte, die unter Linux, MacOS und Windows laufen.

Installation von IronPDF und PDFSharpCore

Installation von IronPDF

Um IronPDF in Ihrem Projekt zu verwenden, können Sie es einfach über den NuGet Package Manager installieren. Folgen Sie diesen Schritten, um IronPDF zu installieren:

Öffnen Sie Ihr Projekt in Visual Studio.
Navigieren Sie zu Tools > NuGet Package Manager > NuGet-Pakete für die Lösung verwalten.
Suchen Sie im NuGet Manager nach IronPdf.
1. Wählen Sie Ihr Projekt aus und klicken Sie dann auf Installieren, um IronPDF zu Ihrem Projekt hinzuzufügen.
Alternativ können Sie IronPDF auch über die Paketmanager-Konsole mit dem folgenden Befehl installieren:

Install-Package IronPdf

Installation von PDFSharpCore

Um PDFSharpCore mit NuGet zu installieren, folgen Sie diesen Anweisungen:

Stellen Sie sicher, dass Ihr Visual Studio-Projekt geöffnet ist.
Gehen Sie zu Tools > NuGet Package Manager > NuGet-Pakete für die Lösung verwalten.
Suchen Sie im NuGet Package Manager nach PDFSharpCore.
1. Wählen Sie Ihr Projekt aus und klicken Sie auf Installieren, um PDFSharpCore einzubinden.
Für Entwickler, die die Paketmanager-Konsole bevorzugen, kann PDFSharpCore mit diesem Befehl installiert werden:

Install-Package PdfSharpCore

PDF-Datei erstellen: IronPDF vs. PDFSharpCore

IronPDF: Einfache Erstellung und Manipulation

IronPDF vereinfacht den Prozess der Erstellung neuer PDF-Dokumente für Entwickler. Es bietet eine intuitive Möglichkeit, PDFs direkt aus HTML-Inhalten oder Webseiten zu erstellen und so die Umwandlung von Webinhalten in Dateien im portablen Dokumentenformat zu optimieren.

HTML-String zu PDF

IronPDF ermöglicht die erstellung von PDF-Dokumenten aus HTML-Strings unter Verwendung der Klasse ChromePdfRenderer. Diese Funktion ist besonders nützlich, wenn Sie PDFs dynamisch aus HTML-Templates oder aus innerhalb Ihrer Anwendung generierten Inhalten erzeugen müssen. So konvertieren Sie einen HTML-String mit IronPDF in ein PDF-Dokument:

using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        // Create a new instance of IronPdf.ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();
        // HTML content with meaningful content
        string htmlContent = @"
                <h1>Report on Sales Performance</h1>
                <p>This report analyzes the sales performance for the first quarter of 2024.</p>
                <table>
                    <thead>
                        <tr>
                            <th>Month</th>
                            <th>Sales Revenue</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td>January</td>
                            <td>$50,000</td>
                        </tr>
                        <tr>
                            <td>February</td>
                            <td>$55,000</td>
                        </tr>
                        <tr>
                            <td>March</td>
                            <td>$60,000</td>
                        </tr>
                    </tbody>
                </table>
                <p>This report highlights the positive growth in sales revenue over the quarter.</p>";
        // Render HTML content as PDF
        var PDF = Renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF as example.pdf
        PDF.SaveAs("example.pdf");
        Console.WriteLine("PDF saved successfully.");
    }
}

using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        // Create a new instance of IronPdf.ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();
        // HTML content with meaningful content
        string htmlContent = @"
                <h1>Report on Sales Performance</h1>
                <p>This report analyzes the sales performance for the first quarter of 2024.</p>
                <table>
                    <thead>
                        <tr>
                            <th>Month</th>
                            <th>Sales Revenue</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td>January</td>
                            <td>$50,000</td>
                        </tr>
                        <tr>
                            <td>February</td>
                            <td>$55,000</td>
                        </tr>
                        <tr>
                            <td>March</td>
                            <td>$60,000</td>
                        </tr>
                    </tbody>
                </table>
                <p>This report highlights the positive growth in sales revenue over the quarter.</p>";
        // Render HTML content as PDF
        var PDF = Renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF as example.pdf
        PDF.SaveAs("example.pdf");
        Console.WriteLine("PDF saved successfully.");
    }
}

Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		' Create a new instance of IronPdf.ChromePdfRenderer
		Dim Renderer = New ChromePdfRenderer()
		' HTML content with meaningful content
		Dim htmlContent As String = "
                <h1>Report on Sales Performance</h1>
                <p>This report analyzes the sales performance for the first quarter of 2024.</p>
                <table>
                    <thead>
                        <tr>
                            <th>Month</th>
                            <th>Sales Revenue</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td>January</td>
                            <td>$50,000</td>
                        </tr>
                        <tr>
                            <td>February</td>
                            <td>$55,000</td>
                        </tr>
                        <tr>
                            <td>March</td>
                            <td>$60,000</td>
                        </tr>
                    </tbody>
                </table>
                <p>This report highlights the positive growth in sales revenue over the quarter.</p>"
		' Render HTML content as PDF
		Dim PDF = Renderer.RenderHtmlAsPdf(htmlContent)
		' Save the PDF as example.pdf
		PDF.SaveAs("example.pdf")
		Console.WriteLine("PDF saved successfully.")
	End Sub
End Class

VB C#

Ein Vergleich zwischen IronPDF und PDFSharpCore: Abbildung 3 - Ausgabe des gesendeten PDF-Berichts

HTML-Datei zu PDF

IronPDF unterstützt auch die Konvertierung ganzer HTML-Dateien in PDF-Dokumente. Dies ist besonders nützlich, um statische HTML-Seiten oder als Dateien gespeicherte Vorlagen in das PDF-Format zu konvertieren. Hier ein Codebeispiel für die Umwandlung einer HTML-Datei in ein PDF-Dokument:

using IronPdf;
class Program
{
    void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        // Create a new instance of IronPdf.ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();
        // Render HTML content as PDF
        var PDF = Renderer.RenderHtmlFileAsPdf(@"C:\Users\Tayyab Ali\Desktop\example.html");
        PDF.SaveAs("example.pdf");
        Console.WriteLine("PDF saved successfully.");
    }
}

using IronPdf;
class Program
{
    void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        // Create a new instance of IronPdf.ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();
        // Render HTML content as PDF
        var PDF = Renderer.RenderHtmlFileAsPdf(@"C:\Users\Tayyab Ali\Desktop\example.html");
        PDF.SaveAs("example.pdf");
        Console.WriteLine("PDF saved successfully.");
    }
}

Imports IronPdf
Friend Class Program
	Private Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		' Create a new instance of IronPdf.ChromePdfRenderer
		Dim Renderer = New ChromePdfRenderer()
		' Render HTML content as PDF
		Dim PDF = Renderer.RenderHtmlFileAsPdf("C:\Users\Tayyab Ali\Desktop\example.html")
		PDF.SaveAs("example.pdf")
		Console.WriteLine("PDF saved successfully.")
	End Sub
End Class

VB C#

Ein Vergleich zwischen IronPDF und PDFSharpCore: Abbildung 4 - PDF-Ausgabe

URL zu PDF

Die Konvertierung von Webseiten in PDFs ist eine weitere leistungsstarke Funktion von IronPDF. Diese Funktion ist von unschätzbarem Wert, wenn es darum geht, Live-Webinhalte, einschließlich Styling und Medien, direkt in einem PDF-Dokument zu erfassen. Um eine Web-URL in ein PDF-Dokument zu konvertieren, können Sie den folgenden Code verwenden:

using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        // Create a new instance of IronPdf.ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();
        Renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A2;
        // Render HTML content as PDF
        var PDF = Renderer.RenderUrlAsPdf("https://dotnet.microsoft.com/en-us/download/dotnet-framework");
        // Save the PDF as example.pdf
        PDF.SaveAs("webpage.pdf");
        Console.WriteLine("PDF saved successfully.");
    }
}

using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        // Create a new instance of IronPdf.ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();
        Renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A2;
        // Render HTML content as PDF
        var PDF = Renderer.RenderUrlAsPdf("https://dotnet.microsoft.com/en-us/download/dotnet-framework");
        // Save the PDF as example.pdf
        PDF.SaveAs("webpage.pdf");
        Console.WriteLine("PDF saved successfully.");
    }
}

Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		' Create a new instance of IronPdf.ChromePdfRenderer
		Dim Renderer = New ChromePdfRenderer()
		Renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A2
		' Render HTML content as PDF
		Dim PDF = Renderer.RenderUrlAsPdf("https://dotnet.microsoft.com/en-us/download/dotnet-framework")
		' Save the PDF as example.pdf
		PDF.SaveAs("webpage.pdf")
		Console.WriteLine("PDF saved successfully.")
	End Sub
End Class

VB C#

Ein Vergleich zwischen IronPDF und PDFSharpCore: Abbildung 5 - URL zu PDF-Ausgabe

PDFSharpCore: Flexibilität und Kontrolle

PDFSharpCore ist eine Teilportierung von PDFsharp für .NET Core und bietet detaillierte Kontrolle über den Prozess der Erstellung von PDF-Dokumenten. Es wandelt HTML nicht direkt in PDF um, sondern bietet umfangreiche Funktionen, um ein neues Dokument von Grund auf zu erstellen oder bestehende PDF-Dateien zu ändern. Hier ist ein einfaches Beispiel mit PDFSharpCore:

var doc = new PdfDocument();
var page = doc.AddPage();
var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("Verdana", 20, XFontStyle.Bold);
graphics.DrawString("Hello, World!", font, XBrushes.Black, new XRect(0, 0, page.Width, page.Height), XStringFormats.Center);
doc.Save("newdocument.pdf");

var doc = new PdfDocument();
var page = doc.AddPage();
var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("Verdana", 20, XFontStyle.Bold);
graphics.DrawString("Hello, World!", font, XBrushes.Black, new XRect(0, 0, page.Width, page.Height), XStringFormats.Center);
doc.Save("newdocument.pdf");

Dim doc = New PdfDocument()
Dim page = doc.AddPage()
Dim graphics = XGraphics.FromPdfPage(page)
Dim font = New XFont("Verdana", 20, XFontStyle.Bold)
graphics.DrawString("Hello, World!", font, XBrushes.Black, New XRect(0, 0, page.Width, page.Height), XStringFormats.Center)
doc.Save("newdocument.pdf")

VB C#

Ein Vergleich zwischen IronPDF und PDFSharpCore: Abbildung 6 - PDFSharpCore-Ausgabe

Handhabung komplexer PDF-Aufgaben: Erweiterte Funktionen

Erweiterte Funktionen von IronPDF

IronPDF zeichnet sich bei der Bewältigung anspruchsvoller PDF-Aufgaben aus. Es bietet unter anderem folgende Funktionen:

PDF/A-Konformität: Die Fähigkeit von IronPDF zur Erzeugung von PDF/A-konforme Dokumente ist für Unternehmen, die eine langfristige digitale Bewahrung benötigen, unerlässlich. Diese Funktion stellt sicher, dass PDF-Dateien so erstellt werden, dass sie strengen Archivierungsstandards entsprechen und die Integrität der Dokumente im Laufe der Zeit erhalten bleibt.

using IronPdf;
// Open a PDF 
PdfDocument pdf = PdfDocument.FromFile("example.pdf");
// Save the PDF/A-3b
pdf.SaveAsPdfA("PDFA-Document.pdf", PdfAVersions.PdfA3);

using IronPdf;
// Open a PDF 
PdfDocument pdf = PdfDocument.FromFile("example.pdf");
// Save the PDF/A-3b
pdf.SaveAsPdfA("PDFA-Document.pdf", PdfAVersions.PdfA3);

Imports IronPdf
' Open a PDF 
Private pdf As PdfDocument = PdfDocument.FromFile("example.pdf")
' Save the PDF/A-3b
pdf.SaveAsPdfA("PDFA-Document.pdf", PdfAVersions.PdfA3)

VB C#

Wasserzeichen und Sicherheit: IronPDF bietet robuste Werkzeuge für hinzufügen von Wasserzeichen zu PDF-Dokumenten, was für das Branding und den Urheberrechtsschutz von entscheidender Bedeutung ist. Darüber hinaus unterstützt es umfassende Sicherheitsfunktionen, darunter die Möglichkeit, PDF-Dateien zu verschlüsseln, Benutzerrechte festzulegen und digitale Signaturen hinzuzufügen. Dadurch wird sichergestellt, dass sensible Informationen sicher bleiben und die Integrität der Dokumente gewahrt wird.

using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello, IronPdf!</h1></body></html>");
        pdf.ApplyWatermark("<h2 style='color:red'>SAMPLE WATERMARK</h2>", 30, IronPdf.Editing.VerticalAlignment.Middle, IronPdf.Editing.HorizontalAlignment.Center);
        pdf.SecuritySettings.OwnerPassword = "top-secret"; // password to edit the pdf
        pdf.SecuritySettings.UserPassword = "sharable"; // password to open the pdf
        pdf.SaveAs("CombinedPDF.pdf");
        Console.WriteLine("PDF generated successfully!");
    }
}

using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello, IronPdf!</h1></body></html>");
        pdf.ApplyWatermark("<h2 style='color:red'>SAMPLE WATERMARK</h2>", 30, IronPdf.Editing.VerticalAlignment.Middle, IronPdf.Editing.HorizontalAlignment.Center);
        pdf.SecuritySettings.OwnerPassword = "top-secret"; // password to edit the pdf
        pdf.SecuritySettings.UserPassword = "sharable"; // password to open the pdf
        pdf.SaveAs("CombinedPDF.pdf");
        Console.WriteLine("PDF generated successfully!");
    }
}

Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello, IronPdf!</h1></body></html>")
		pdf.ApplyWatermark("<h2 style='color:red'>SAMPLE WATERMARK</h2>", 30, IronPdf.Editing.VerticalAlignment.Middle, IronPdf.Editing.HorizontalAlignment.Center)
		pdf.SecuritySettings.OwnerPassword = "top-secret" ' password to edit the pdf
		pdf.SecuritySettings.UserPassword = "sharable" ' password to open the pdf
		pdf.SaveAs("CombinedPDF.pdf")
		Console.WriteLine("PDF generated successfully!")
	End Sub
End Class

VB C#

Ein Vergleich zwischen IronPDF und PDFSharpCore: Abbildung 7 - Passwortgeschützte PDF-Ausgabe

Bearbeiten und Zusammenführen von PDFs: IronPDF geht über die Erstellung hinaus und bietet Funktionen zur Bearbeitung von Inhalten in bestehenden PDF-Dateien. Dies kann Textbearbeitung, Bildmanipulation und Layoutanpassungen umfassen. Darüber hinaus ermöglicht die Zusammenführungsfunktion die zusammenführung mehrerer PDF-Dokumente in eine einzige Datei, was die Verwaltung und Verteilung von Dokumenten vereinfacht.

using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        const string html_a = @"<p> [PDF_A] </p>
            <p> [PDF_A] 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> [PDF_A] 2nd Page</p>";
        const string html_b = @"<p> [PDF_B] </p>
            <p> [PDF_B] 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> [PDF_B] 2nd Page</p>";
        const string html_c =
            @"<p> Hello Iron </p>
            <p> This is 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> This is 2nd Page</p>
            <div style='page-break-after: always;'></div>
            <p> This is 3rd Page</p>";
        var renderer = new ChromePdfRenderer();
        var pdfdoc_a = renderer.RenderHtmlAsPdf(html_a);
        var pdfdoc_b = renderer.RenderHtmlAsPdf(html_b);
        var merged = PdfDocument.Merge(pdfdoc_a, pdfdoc_b);
        var pdfdoc_c = renderer.RenderHtmlAsPdf(html_c);
        merged.AppendPdf(pdfdoc_c);
        merged.SaveAs("CombinedDocument.pdf");
        Console.WriteLine("PDF generated successfully!");
    }
}

using IronPdf;
class Program
{
    static void Main(string [] args)
    {
        const string html_a = @"<p> [PDF_A] </p>
            <p> [PDF_A] 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> [PDF_A] 2nd Page</p>";
        const string html_b = @"<p> [PDF_B] </p>
            <p> [PDF_B] 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> [PDF_B] 2nd Page</p>";
        const string html_c =
            @"<p> Hello Iron </p>
            <p> This is 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> This is 2nd Page</p>
            <div style='page-break-after: always;'></div>
            <p> This is 3rd Page</p>";
        var renderer = new ChromePdfRenderer();
        var pdfdoc_a = renderer.RenderHtmlAsPdf(html_a);
        var pdfdoc_b = renderer.RenderHtmlAsPdf(html_b);
        var merged = PdfDocument.Merge(pdfdoc_a, pdfdoc_b);
        var pdfdoc_c = renderer.RenderHtmlAsPdf(html_c);
        merged.AppendPdf(pdfdoc_c);
        merged.SaveAs("CombinedDocument.pdf");
        Console.WriteLine("PDF generated successfully!");
    }
}

Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Const html_a As String = "<p> [PDF_A] </p>
            <p> [PDF_A] 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> [PDF_A] 2nd Page</p>"
		Const html_b As String = "<p> [PDF_B] </p>
            <p> [PDF_B] 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> [PDF_B] 2nd Page</p>"
		Const html_c As String = "<p> Hello Iron </p>
            <p> This is 1st Page </p>
            <div style='page-break-after: always;'></div>
            <p> This is 2nd Page</p>
            <div style='page-break-after: always;'></div>
            <p> This is 3rd Page</p>"
		Dim renderer = New ChromePdfRenderer()
		Dim pdfdoc_a = renderer.RenderHtmlAsPdf(html_a)
		Dim pdfdoc_b = renderer.RenderHtmlAsPdf(html_b)
		Dim merged = PdfDocument.Merge(pdfdoc_a, pdfdoc_b)
		Dim pdfdoc_c = renderer.RenderHtmlAsPdf(html_c)
		merged.AppendPdf(pdfdoc_c)
		merged.SaveAs("CombinedDocument.pdf")
		Console.WriteLine("PDF generated successfully!")
	End Sub
End Class

VB C#

Ein Vergleich zwischen IronPDF und PDFSharpCore: Abbildung 8 - PDF-Ausgabe bearbeiten

Erweiterte Funktionen von PDFSharpCore

PDFSharpCore konzentriert sich zwar mehr auf die Grundlagen, bietet aber dennoch Funktionen für komplexe Aufgaben, wie z. B.:

Dokumentenmodifikation: PDFSharpCore erleichtert die Modifikation von bestehenden PDF-Dokumenten. Dazu gehören Aufgaben wie das Hinzufügen oder Entfernen von Seiten, das Aktualisieren von Text und das Einfügen von Bildern.

using PdfSharpCore.Pdf;
using PdfSharpCore.Pdf.IO;
// Open an existing PDF document
var inputDocument = PdfReader.Open("input.pdf", PdfDocumentOpenMode.Modify);
// Modify the first page
var page = inputDocument.Pages [0];
var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("OpenSans", 20, XFontStyle.Bold);
graphics.DrawString("Added Text", font, XBrushes.Black, new XPoint(50, 100));
// Save the modified document
inputDocument.Save("modified.pdf");

using PdfSharpCore.Pdf;
using PdfSharpCore.Pdf.IO;
// Open an existing PDF document
var inputDocument = PdfReader.Open("input.pdf", PdfDocumentOpenMode.Modify);
// Modify the first page
var page = inputDocument.Pages [0];
var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("OpenSans", 20, XFontStyle.Bold);
graphics.DrawString("Added Text", font, XBrushes.Black, new XPoint(50, 100));
// Save the modified document
inputDocument.Save("modified.pdf");

Imports PdfSharpCore.Pdf
Imports PdfSharpCore.Pdf.IO
' Open an existing PDF document
Private inputDocument = PdfReader.Open("input.pdf", PdfDocumentOpenMode.Modify)
' Modify the first page
Private page = inputDocument.Pages (0)
Private graphics = XGraphics.FromPdfPage(page)
Private font = New XFont("OpenSans", 20, XFontStyle.Bold)
graphics.DrawString("Added Text", font, XBrushes.Black, New XPoint(50, 100))
' Save the modified document
inputDocument.Save("modified.pdf")

VB C#

Grafik und Zeichnen: Die Bibliothek nutzt dieselben Zeichenroutinen, die auch in PDFSharp verfügbar sind, und ermöglicht es Entwicklern, komplexe grafische Elemente in PDF-Dokumente einzubinden. Dazu gehören das Zeichnen von Formen, die Verwendung verschiedener Schriftarten und die Anwendung von Farben.

using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;
// Create a new PDF document
var document = new PdfDocument();
var page = document.AddPage();
var graphics = XGraphics.FromPdfPage(page);
// Draw a rectangle
graphics.DrawRectangle(XPens.Black, XBrushes.SkyBlue, 40, 100, 250, 120);
// Draw text
var font = new XFont("Verdana", 20, XFontStyle.BoldItalic);
graphics.DrawString("Hello, PDFSharpCore!", font, XBrushes.Black, new XRect(0, 0, page.Width, page.Height), XStringFormats.Center);
// Save the document
document.Save("drawing.pdf");

using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;
// Create a new PDF document
var document = new PdfDocument();
var page = document.AddPage();
var graphics = XGraphics.FromPdfPage(page);
// Draw a rectangle
graphics.DrawRectangle(XPens.Black, XBrushes.SkyBlue, 40, 100, 250, 120);
// Draw text
var font = new XFont("Verdana", 20, XFontStyle.BoldItalic);
graphics.DrawString("Hello, PDFSharpCore!", font, XBrushes.Black, new XRect(0, 0, page.Width, page.Height), XStringFormats.Center);
// Save the document
document.Save("drawing.pdf");

Imports PdfSharpCore.Drawing
Imports PdfSharpCore.Pdf
' Create a new PDF document
Private document = New PdfDocument()
Private page = document.AddPage()
Private graphics = XGraphics.FromPdfPage(page)
' Draw a rectangle
graphics.DrawRectangle(XPens.Black, XBrushes.SkyBlue, 40, 100, 250, 120)
' Draw text
Dim font = New XFont("Verdana", 20, XFontStyle.BoldItalic)
graphics.DrawString("Hello, PDFSharpCore!", font, XBrushes.Black, New XRect(0, 0, page.Width, page.Height), XStringFormats.Center)
' Save the document
document.Save("drawing.pdf")

VB C#

Ein Vergleich zwischen IronPDF und PDFSharpCore: Abbildung 9 - Grafikausgabe

PDF-Erzeugung aus Daten: PDFSharpCore zeichnet sich dadurch aus, dass es PDF-Dokumente dynamisch aus Anwendungsdaten erzeugt. Dies ist besonders vorteilhaft für die Erstellung von Berichten, Rechnungen oder anderen Dokumenten, die dynamische Daten enthalten müssen.

using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;
// Create a new PDF document
var document = new PdfDocument();
var page = document.AddPage();
var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("Arial", 12);
// Simulate generation
var data = new List<string> { "Data 1", "Data 2", "Data 3" };
// Generate PDF from data
var yPos = 20;
foreach (var item in data)
{
    graphics.DrawString(item, font, XBrushes.Black, new XRect(0, yPos, page.Width, page.Height), XStringFormats.TopLeft);
    yPos += 20;
}
// Save the document
document.Save("data-generated.pdf");

using PdfSharpCore.Drawing;
using PdfSharpCore.Pdf;
// Create a new PDF document
var document = new PdfDocument();
var page = document.AddPage();
var graphics = XGraphics.FromPdfPage(page);
var font = new XFont("Arial", 12);
// Simulate generation
var data = new List<string> { "Data 1", "Data 2", "Data 3" };
// Generate PDF from data
var yPos = 20;
foreach (var item in data)
{
    graphics.DrawString(item, font, XBrushes.Black, new XRect(0, yPos, page.Width, page.Height), XStringFormats.TopLeft);
    yPos += 20;
}
// Save the document
document.Save("data-generated.pdf");

Imports PdfSharpCore.Drawing
Imports PdfSharpCore.Pdf
' Create a new PDF document
Private document = New PdfDocument()
Private page = document.AddPage()
Private graphics = XGraphics.FromPdfPage(page)
Private font = New XFont("Arial", 12)
' Simulate generation
Private data = New List(Of String) From {"Data 1", "Data 2", "Data 3"}
' Generate PDF from data
Private yPos = 20
For Each item In data
	graphics.DrawString(item, font, XBrushes.Black, New XRect(0, yPos, page.Width, page.Height), XStringFormats.TopLeft)
	yPos += 20
Next item
' Save the document
document.Save("data-generated.pdf")

VB C#

Schlussfolgerung

Ein Vergleich zwischen IronPDF und PDFSharpCore: Abbildung 10 - Lizenzierung

Wenn es um die Integration von PDF-Funktionalität in Ihre .NET-Projekte geht, verdient die Wahl zwischen IronPDF und PDFSharpCore eine sorgfältige Abwägung, wobei IronPDF aus mehreren zwingenden Gründen einen besonderen Vorteil hat. IronPDF zeichnet sich durch eine umfangreichere Palette an Funktionen und Möglichkeiten aus, insbesondere für Entwickler, die Webanwendungen und umfassende PDF-Verarbeitungsanforderungen priorisieren.

IronPDF zeichnet sich durch seine Benutzerfreundlichkeit und Flexibilität aus und ermöglicht Entwicklern die mühelose Konvertierung von HTML in PDF, eine wichtige Funktion für moderne Webanwendungen, bei denen Inhalte häufig im HTML-Format erstellt und präsentiert werden. Darüber hinaus unterstützt IronPDF erweiterte PDF-Funktionen wie Bearbeitung, Zusammenführung, Sicherheit und Einhaltung der PDF/A-Standards und bietet damit ein robustes Toolkit für die Verwaltung komplexer PDF-Vorgänge.

IronPDF zeichnet sich nicht nur durch seinen umfassenden Funktionsumfang aus, sondern auch durch das Angebot einer kostenloser Testund ermöglicht es den Entwicklern, die Möglichkeiten des Systems ohne Anfangsinvestitionen zu testen. Für diejenigen, die IronPDF in ihren Entwicklungsworkflow integrieren möchten, beginnt die Lizenzierung bei $749.

< PREVIOUS
Ein Vergleich der PDF-Aufteilung in C# zwischen iTextSharp und IronPDF

NÄCHSTES >
Ein Vergleich zwischen IronPDF und Apryse C#