Die C# PDF-Bibliothek
using IronPdf;
// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;
// Instantiate Renderer
var renderer = new ChromePdfRenderer();
// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
// Export to a file or Stream
pdf.SaveAs("output.pdf");
// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");
Install-Package IronPdf
In diesem Artikel werden wir einen genaueren Blick auf zwei beliebte C#-Bibliotheken werfen, die für die Arbeit mit PDF-Dateien verwendet werden: IronPDF - Die .NET PDF-Bibliothek für C#-Entwickler und Report.NET. Diese Werkzeuge sind unverzichtbar für Entwickler, die in ihren C#-Anwendungen PDF-Dokumente erstellen, ändern oder mit ihnen interagieren müssen. Beide Bibliotheken bieten eine Reihe von Funktionen, die den Umgang mit PDFs einfacher und effizienter machen sollen, aber sie tun dies auf unterschiedliche Weise.
IronPDF und Report.NET ermöglichen es Entwicklern, dynamisch Dokumente zu erstellen, Inhalte zu bearbeiten und Text und Bilder aus PDFs zu ziehen. Sie unterstützen auch die Verarbeitung von Formularen, das Hinzufügen digitaler Signaturen und stellen sicher, dass Anwendungen PDF-Dateien auf verschiedenen Plattformen verarbeiten können, ohne dass die Dokumententreue verloren geht. Das bedeutet, dass die PDF-Dateien unabhängig vom Gerät oder Betriebssystem wie vorgesehen aussehen und funktionieren.
In diesem Vergleich werden wir auf die spezifischen Funktionen jeder Bibliothek eingehen, ihre Funktionsweise erläutern, Codeschnipsel zur Veranschaulichung ihrer Verwendung bereitstellen und ihre Lizenzbedingungen diskutieren. Dieser Vergleich soll Entwicklern ein klares Verständnis dafür vermitteln, was die einzelnen Bibliotheken leisten können, und ihnen bei der Entscheidung helfen, welche Bibliothek für ihre Projektanforderungen am besten geeignet ist. Lassen Sie uns die Fähigkeiten und Unterschiede zwischen IronPDF und Report.NET aufschlüsseln, wobei der Fokus auf Einfachheit und praktischen Einblicken für Entwickler liegt.
Report.NET ist eine robuste C#-Bibliothek, die Entwicklern hilft, PDF-Dokumente direkt innerhalb ihrer .NET-Anwendungen zu erstellen, zu verwalten und zu manipulieren. Dieses Tool ist bekannt für seinen einfachen Ansatz bei der PDF-Erzeugung und -Bearbeitung und ermöglicht die Erstellung komplexer PDF-Dokumente von Grund auf oder die Modifizierung bestehender Dokumente. Seine Möglichkeiten reichen vom einfachen Hinzufügen von Text bis hin zur Einbindung von Bildern und Formen, was es zu einer vielseitigen Wahl für Entwickler macht, die PDF-Funktionen in ihre Projekte implementieren möchten.
Report.NET eignet sich hervorragend für die Erstellung neuer und die Bearbeitung bestehender PDF-Dokumente. Entwickler können problemlos Text, Bilder und Grafiken hinzufügen und so detaillierte und visuell ansprechende Dokumente erstellen.
Diese Bibliothek ermöglicht eine genaue Kontrolle über den Inhalt des Dokuments, einschließlich Textformatierung, Bildplatzierung und grafischer Elemente. Dieses Maß an Kontrolle stellt sicher, dass die endgültige PDF-Datei genau so aussieht wie gewünscht.
Mit dem Schwerpunkt auf Einfachheit vereinfacht Report.NET den PDF-Erzeugungsprozess und macht ihn auch für diejenigen zugänglich, die zum ersten Mal mit PDFs in einem Programmierkontext arbeiten.
Report.NET ist so konzipiert, dass es nahtlos mit der .NET-Plattform, einschließlich .NET Core, zusammenarbeitet, so dass Anwendungen unabhängig vom Betriebssystem PDFs erzeugen und verwalten können.
Die Bibliothek bietet umfangreiche Anpassungsoptionen für PDF-Dokumente, die es Entwicklern ermöglichen, das Layout, das Styling und das Gesamterscheinungsbild an ihre spezifischen Anforderungen anzupassen.
Als Open-Source-Tool profitiert Report.NET von den Beiträgen der Community, wodurch sichergestellt wird, dass es ständig aktualisiert wird und im Laufe der Zeit neue Funktionen erhält. Diese Unterstützung durch die Community bedeutet auch, dass Entwickler auf eine Fülle von Wissen und Ressourcen zugreifen können.
IronPDF ist eine umfassende .NET-Bibliothek, die entwickelt wurde, um die Erstellung, Bearbeitung und Darstellung von PDF-Dokumenten in .NET-Anwendungen zu erleichtern. Dieses Werkzeug zeichnet sich dadurch aus, dass es sowohl die Erzeugung von PDFs aus HTML als auch die direkte Bearbeitung bestehender PDF-Dateien ermöglicht. Es ist sehr hilfreich, Berichte zu erstellen. IronPDF lässt sich auch nahtlos in die SQL Server Reporting Services integrieren. Wir können mit IronPDF einen Berichtsdesigner für Endbenutzer erstellen, um ein Berichtswerkzeug und einen Berichtsbetrachter zu entwickeln.
Eine der Kernstärken von IronPDF ist seine Fähigkeit, HTML und CSS in PDF-Dokumente zu konvertieren. Diese Funktion ist von unschätzbarem Wert für Entwickler, die Webinhalte in ein portables Format umwandeln und dabei das ursprüngliche Design und Layout beibehalten wollen.
IronPDF zeichnet sich dadurch aus, dass es Entwicklern Werkzeuge zur Bearbeitung und Manipulation von PDF-Dokumenten zur Verfügung stellt. Dies umfasst das Hinzufügen oder Entfernen von Seiten, das Ändern von Text und das Einbetten von Bildern. Mit IronPDF können wir auch Berichtsdaten aus den Berichten extrahieren.
Die Bibliothek unterstützt die Erstellung und Bearbeitung von PDF-Formularen, wodurch Benutzer in der Lage sind, auf dynamische Weise mit Dokumenten zu interagieren. Diese Funktion ist von entscheidender Bedeutung für Anwendungen, die Eingaben von Endnutzern erfordern, wie z. B. Umfragen oder Antragsformulare.
Mit IronPDF ist die Implementierung von Sicherheitsmaßnahmen wie Verschlüsselung und Passwortschutz unkompliziert. Diese Funktionen gewährleisten, dass sensible Informationen in PDF-Dokumenten vor unbefugtem Zugriff geschützt sind.
IronPDF ermöglicht es Entwicklern, PDFs sowohl für die Bildschirmansicht als auch für das drucken auf Papier zu rendern, wobei in beiden Fällen eine hohe Ausgabequalität sichergestellt wird. Dies erleichtert die Vorbereitung von Dokumenten für eine Reihe von Präsentations- oder Verteilungsanforderungen.
IronPDF arbeitet auf verschiedenen .NET-Plattformen, hält sich an .NET-Code-Standards und erleichtert die Entwicklung in verschiedenen Umgebungen ohne Kompatibilitätsprobleme.
IronPDF wird durch detaillierte Dokumentation und engagierten Support unterstützt, was den Entwicklern hilft, die Funktionen der Bibliothek zu verstehen und ihre Funktionalitäten effizient in ihre Anwendungen zu integrieren.
IronPDF bietet viele erweiterte Bearbeitungsfunktionen. Dies umfasst die Fähigkeit, PDF-Dokumente zu verbinden und zu teilen, was besonders nützlich ist, um große Informationsmengen zu organisieren oder bestimmte Abschnitte aus einem Dokument zur getrennten Nutzung zu extrahieren.
Die Bibliothek ermöglicht die Anpassung von Kopf- und Fußzeilen in PDF-Dokumenten. Diese Funktion ist unverzichtbar, wenn es darum geht, ein einheitliches Branding, Seitenzahlen oder Dokumententitel über mehrere Seiten hinweg einzufügen und so das professionelle Erscheinungsbild der Ausgabe zu verbessern.
Das Erstellen einer Konsolenanwendung in Visual Studio IDE ist ein einfacher Prozess, der mehrere Schritte umfasst.
Beginnen Sie mit dem Öffnen von Microsoft Visual Studio. Wenn Sie es nicht installiert haben, müssen Sie es von der offiziellen Microsoft-Website herunterladen und installieren. Nach der Installation starten Sie das Visual Studio.
Nach dem Öffnen von Visual Studio werden Sie mit dem Startfenster begrüßt. Wählen Sie hier die Option "Neues Projekt erstellen", um die Einrichtung einer neuen Konsolenanwendung einzuleiten.
Im Fenster "Neues Projekt erstellen" sehen Sie eine Reihe von Projektvorlagen. Geben Sie "console" in das Suchfeld ein, um die Optionen zu filtern, und wählen Sie dann "Console App" aus der Liste. Stellen Sie sicher, dass Sie die Vorlage auswählen, die der gewünschten Programmiersprache entspricht, z. B. C#.
Wenn Sie die Vorlage für die Konsolenanwendung ausgewählt haben, klicken Sie auf "Weiter", um zum Bildschirm für die Projektkonfiguration zu gelangen. Hier müssen Sie einige Angaben zu Ihrem Projekt machen:
Projektname: Geben Sie Ihrem Projekt einen aussagekräftigen Namen, der seinen Zweck widerspiegelt.
Lösungsname : Standardmäßig ist dies derselbe wie Ihr Projektname, aber Sie können ihn ändern, wenn Sie planen, mehrere Projekte in derselben Lösung einzuschließen.
Nachdem Sie alle erforderlichen Informationen eingegeben haben, klicken Sie auf die Schaltfläche "Erstellen". Visual Studio generiert nun ein neues Konsolenanwendungsprojekt basierend auf Ihren Angaben. Dieser Vorgang kann einige Augenblicke dauern.
Um die Möglichkeiten von IronPDF in Ihrem Projekt nutzen zu können, müssen Sie die Bibliothek zunächst installieren. Hierfür gibt es mehrere Methoden, die jeweils für unterschiedliche Entwicklungsabläufe oder Präferenzen geeignet sind. Im Folgenden werden drei gängige Methoden zur Installation der IronPDF-Bibliothek in Ihr Visual Studio-Projekt beschrieben.
Die NuGet-Paketmanager-Benutzeroberfläche in Visual Studio bietet eine unkomplizierte Möglichkeit zum Durchsuchen, Auswählen und Installieren von Paketen.
Navigieren Sie in Visual Studio zu Ihrem Projekt im Projektmappen-Explorer, klicken Sie mit der rechten Maustaste darauf und wählen Sie die Option "NuGet-Pakete verwalten...".
Klicken Sie auf die Registerkarte "Durchsuchen" und geben Sie "IronPDF" in das Suchfeld ein.
Suchen Sie das IronPDF-Paket in den Suchergebnissen, wählen Sie es aus und klicken Sie dann auf die Schaltfläche "Installieren". Der Download und die Installation werden von Visual Studio automatisch durchgeführt.
Für diejenigen, die die Verwendung von Befehlszeilentools bevorzugen, ist die NuGet Package Manager Console eine leistungsstarke Alternative.
Konsole öffnen: Gehen Sie im Visual Studio zum Menü „Tools“ und navigieren Sie dann zu „NuGet-Paket-Manager“ > „Paket-Manager-Konsole“.
Install-Package IronPdfDieser Befehl weist NuGet an, die neueste Version von IronPDF herunterzuladen und in Ihrem Projekt zu installieren.
Wenn Sie das Paket lieber manuell herunterladen möchten oder eine bestimmte Version von IronPDF benötigen, ist die NuGet-Website eine gute Option.
Besuchen Sie die NuGet-Website: Gehen Sie zu nuget.org und suchen Sie nach "IronPDF".
Paket herunterladen: Auf der IronPDF-Seite wählen Sie die benötigte Version aus und laden Sie die .nupkg-Datei herunter.
Öffnen Sie Ihren Webbrowser und gehen Sie zum Report.NET GitHub-Repository unter https://github.com/ritchiecarroll/Report.NET/tree/master. Diese Seite enthält die neueste Version der Report.NET-Bibliothek zusammen mit ihrem Quellcode.
Suchen Sie auf der Repository-Seite die Schaltfläche "Code" und klicken Sie sie an. Wählen Sie im Dropdown-Menü "ZIP herunterladen", um das gesamte Repository als ZIP-Datei herunterzuladen. Speichern Sie diese Datei an einem geeigneten Ort auf Ihrem Computer und entpacken Sie den Inhalt.
Nach dem Entpacken der ZIP-Datei finden Sie den Quellcode der Report.NET-Bibliothek in den entpackten Dateien. Gehen Sie folgendermaßen vor, um Report.NET in Ihrem Visual Studio-Projekt zu verwenden:
Öffnen Sie Ihr Projekt: Starten Sie Visual Studio und öffnen Sie das Projekt, zu dem Sie Report.NET hinzufügen möchten.
Bibliothek manuell hinzufügen: Es gibt ein paar Möglichkeiten, die Bibliothek in Ihr Projekt einzubinden:
IronPDF wird mit einer Reihe von fortschrittlichen Funktionen geliefert, die entwickelt wurden, um eine Vielzahl von PDF-bezogenen Aufgaben mühelos zu bearbeiten.
IronPDF kann HTML-Inhalte, einschließlich CSS und JavaScript, direkt in ein PDF-Dokument übertragen. Das bedeutet, dass Webseiten oder HTML-Vorlagen in PDFs umgewandelt werden können, die genauso aussehen wie in einem Browser.
IronPDF ermöglicht die direkte Umwandlung von HTML-Strings in PDF. Das bedeutet, dass Entwickler HTML-Code, der als String-Variable gespeichert ist, mit IronPDF in eine PDF-Datei umwandeln können. Diese Funktion ist besonders nützlich, wenn der HTML-Inhalt vor der Konvertierung dynamisch erzeugt oder von der Anwendung geändert wird.
using IronPdf;
var Renderer = new IronPdf.HtmlToPdf();
var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello IronPDF</h1>");
PDF.SaveAs("HtmlStringToPdf.pdf");using IronPdf;
var Renderer = new IronPdf.HtmlToPdf();
var PDF = Renderer.RenderHtmlAsPdf("<h1>Hello IronPDF</h1>");
PDF.SaveAs("HtmlStringToPdf.pdf");Ebenso kann IronPDF bestehende HTML-Dateien in PDF-Dokumente umwandeln. Dazu wird die HTML-Datei aus dem Dateisystem gelesen und mit IronPDF ein PDF-Dokument mit der gleichen Formatierung und Struktur erstellt.
using IronPdf;
var Renderer = new ChromePdfRenderer();
var PDF = Renderer.RenderHTMLFileAsPdf("invoice.html");
PDF.SaveAs("HtmlFileToPdf.pdf");using IronPdf;
var Renderer = new ChromePdfRenderer();
var PDF = Renderer.RenderHTMLFileAsPdf("invoice.html");
PDF.SaveAs("HtmlFileToPdf.pdf");
IronPDF ist auch in der Lage, ein PDF von einer Live-URL zu rendern. Damit können Entwickler eine Webadresse eingeben, und IronPDF holt den HTML-Inhalt aus der URL und rendert ihn als PDF.
using IronPdf;
var Renderer = new ChromePdfRenderer();
var PDF = Renderer.RenderUrlAsPdf("http://ironpdf.com");
PDF.SaveAs("UrlToPdf.pdf");using IronPdf;
var Renderer = new ChromePdfRenderer();
var PDF = Renderer.RenderUrlAsPdf("http://ironpdf.com");
PDF.SaveAs("UrlToPdf.pdf");
Mit IronPDF können Sie bestehende PDF-Dokumente bearbeiten. Dazu gehört das Hinzufügen von Text, Bildern und Seiten oder das Entfernen von Seiten aus dem Dokument. Sie können auch Text im PDF-Dokument suchen und ersetzen.
using IronPdf;
var document = PdfDocument.FromFile("original_document.pdf");
const int targetPageIndex = 1;
const string oldString = "Hello, World!";
const string newString = "Greetings, Universe!";
document.ReplaceTextOnPage(targetPageIndex, oldString, newString);
document.SaveAs("modified_document.pdf");using IronPdf;
var document = PdfDocument.FromFile("original_document.pdf");
const int targetPageIndex = 1;
const string oldString = "Hello, World!";
const string newString = "Greetings, Universe!";
document.ReplaceTextOnPage(targetPageIndex, oldString, newString);
document.SaveAs("modified_document.pdf");
Diese Bibliothek kann Text und Bilder extrahieren aus PDF-Dateien, ähnlich wie Crystal Reports, die Sie zum Indizieren, Suchen oder zur Wiederverwendung von Inhalten verwenden können.
IronPDF unterstützt die Erstellung von PDF-Formularen. Entwickler können programmgesteuert Formulare in einer PDF-Datei erstellen, die der Benutzer dann ausfüllen kann.
using IronPdf;
using System;
const string alternativeHtmlContent = @"
<html>
<body>
<h2>Alternative PDF Form</h2>
<form>
Name: <br>
Age: <br>
<br>
<p>Select country:</p>
<select name='country'>
<option value='USA'>USA</option>
<option value='UK'>UK</option>
<option value='Canada'>Canada</option>
</select>
<br>
<p>Select interests:</p>
<label for='interest1'> Interest 1</label><br>
<label for='interest2'> Interest 2</label><br>
</form>
</body>
</html>";
var alternativePdfRenderer = new ChromePdfRenderer();
alternativePdfRenderer.RenderingOptions.CreatePdfFormsFromHtml = true;
alternativePdfRenderer.RenderHtmlAsPdf(alternativeHtmlContent).SaveAs("AlternativeForm.pdf");using IronPdf;
using System;
const string alternativeHtmlContent = @"
<html>
<body>
<h2>Alternative PDF Form</h2>
<form>
Name: <br>
Age: <br>
<br>
<p>Select country:</p>
<select name='country'>
<option value='USA'>USA</option>
<option value='UK'>UK</option>
<option value='Canada'>Canada</option>
</select>
<br>
<p>Select interests:</p>
<label for='interest1'> Interest 1</label><br>
<label for='interest2'> Interest 2</label><br>
</form>
</body>
</html>";
var alternativePdfRenderer = new ChromePdfRenderer();
alternativePdfRenderer.RenderingOptions.CreatePdfFormsFromHtml = true;
alternativePdfRenderer.RenderHtmlAsPdf(alternativeHtmlContent).SaveAs("AlternativeForm.pdf");
Sie können mehrere PDF-Dateien zu einem einzigen Dokument zusammenfügen. Diese Funktion ist praktisch, um Berichte zu konsolidieren oder verschiedene Dokumentabschnitte zu kombinieren.
using IronPdf;
var firstHtmlContent = @"<h1>Document A</h1>
<p>This is the first document.</p>
<div style='page-break-after: always;'></div>
<p>Continuation of Document A</p>";
var secondHtmlContent = @"<h1>Document B</h1>
<p>This is the second document.</p>
<div style='page-break-after: always;'></div>
<p>Continuation of Document B</p>";
var pdfRenderer = new ChromePdfRenderer();
var pdfDocA = pdfRenderer.RenderHtmlAsPdf(firstHtmlContent);
var pdfDocB = pdfRenderer.RenderHtmlAsPdf(secondHtmlContent);
var mergedPdf = PdfDocument.Merge(pdfDocA, pdfDocB);
mergedPdf.SaveAs("MergedDocuments.pdf");using IronPdf;
var firstHtmlContent = @"<h1>Document A</h1>
<p>This is the first document.</p>
<div style='page-break-after: always;'></div>
<p>Continuation of Document A</p>";
var secondHtmlContent = @"<h1>Document B</h1>
<p>This is the second document.</p>
<div style='page-break-after: always;'></div>
<p>Continuation of Document B</p>";
var pdfRenderer = new ChromePdfRenderer();
var pdfDocA = pdfRenderer.RenderHtmlAsPdf(firstHtmlContent);
var pdfDocB = pdfRenderer.RenderHtmlAsPdf(secondHtmlContent);
var mergedPdf = PdfDocument.Merge(pdfDocA, pdfDocB);
mergedPdf.SaveAs("MergedDocuments.pdf");
Umgekehrt kann IronPDF ein einzelnes PDF in mehrere Dokumente aufteilen. Dies kann erforderlich sein, wenn Sie einzelne Seiten oder Abschnitte verteilen möchten.
IronPDF ermöglicht die Verschlüsselung und Entschlüsselung von PDF-Dokumenten, wodurch eine zusätzliche Sicherheitsschicht für sensible Informationen hinzugefügt wird.
using IronPdf;
using System;
var encryptedPdf = PdfDocument.FromFile("protected.pdf", "password");
encryptedPdf.SecuritySettings.RemovePasswordsAndEncryption();
encryptedPdf.SecuritySettings.MakePdfDocumentReadOnly("super-secret-key");
encryptedPdf.Password = "new-password";
encryptedPdf.SaveAs("secured.pdf");using IronPdf;
using System;
var encryptedPdf = PdfDocument.FromFile("protected.pdf", "password");
encryptedPdf.SecuritySettings.RemovePasswordsAndEncryption();
encryptedPdf.SecuritySettings.MakePdfDocumentReadOnly("super-secret-key");
encryptedPdf.Password = "new-password";
encryptedPdf.SaveAs("secured.pdf");Mit dieser Bibliothek ist das Festlegen von Dokumenteigenschaften wie Titel, Autor und Metadaten ganz einfach. Dies hilft bei der Verwaltung und Organisation von Dokumenten.
using IronPdf;
using System;
var encryptedPdf = PdfDocument.FromFile("sample.pdf");
pdf.MetaData.Author = "Iron Developer";
pdf.MetaData.Keywords = "Confidential, Private";
pdf.MetaData.ModifiedDate = DateTime.Now;
pdf.SaveAs("modified.pdf");using IronPdf;
using System;
var encryptedPdf = PdfDocument.FromFile("sample.pdf");
pdf.MetaData.Author = "Iron Developer";
pdf.MetaData.Keywords = "Confidential, Private";
pdf.MetaData.ModifiedDate = DateTime.Now;
pdf.SaveAs("modified.pdf");IronPDF kann PDF/A-konforme Dokumente erstellen, die für die Langzeitarchivierung und Dokumentation erforderlich sind.
Die direkte Konvertierung von XML in PDF wird von IronPDF nicht unterstützt, aber ein praktikabler Ansatz besteht darin, die XML-Daten zunächst in das HTML-Format zu konvertieren. Dies wird durch die Verwendung von XSLT (Extensible Stylesheet Language Transformations) erreicht, einer leistungsstarken XML-Stylesheet-Sprache, die für die Transformation von XML-Dokumenten in andere Formate wie HTML, Text oder sogar ein neues XML-Dokument entwickelt wurde. Nehmen wir an, es handelt sich um unsere Datei data.xml:
<?xml version="1.0" encoding="UTF-8"?>
<Library>
<Book id="1">
<Title>The Great Gatsby</Title>
<Author>F. Scott Fitzgerald</Author>
<Genre>Fiction</Genre>
<Year>1925</Year>
</Book>
<Book id="2">
<Title>To Kill a Mockingbird</Title>
<Author>Harper Lee</Author>
<Genre>Fiction</Genre>
<Year>1960</Year>
</Book>
<Book id="3">
<Title>1984</Title>
<Author>George Orwell</Author>
<Genre>Dystopian</Genre>
<Year>1949</Year>
</Book>
</Library>Und das ist unsere style.xslt-Datei:
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="html" doctype-system="about:legacy-compat" encoding="UTF-8" indent="yes"/>
<xsl:template match="/">
<html>
<head>
<title>Library Catalog</title>
<style>
body { font-family: Arial, sans-serif; margin: 20px; }
table { border-collapse: collapse; width: 100%; }
th, td { text-align: left; padding: 8px; }
tr:nth-child(even) { background-color: #f2f2f2; }
th { background-color: #4CAF50; color: white; }
</style>
</head>
<body>
<h2>Library Catalog</h2>
<table>
<tr>
<th>Title</th>
<th>Author</th>
<th>Genre</th>
<th>Year</th>
</tr>
<xsl:for-each select="Library/Book">
<tr>
<td><xsl:value-of select="Title"/></td>
<td><xsl:value-of select="Author"/></td>
<td><xsl:value-of select="Genre"/></td>
<td><xsl:value-of select="Year"/></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>Das folgende Codeschnipsel zeigt, wie wir uns dieser Logik nähern können:
using System;
using System.Xml.Xsl;
using System.Xml;
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load("style.xslt");
XmlReader reader = XmlReader.Create("data.xml");
XmlWriterSettings settings = new XmlWriterSettings { Indent = true, OmitXmlDeclaration = true };
using (XmlWriter writer = XmlWriter.Create("output.html", settings))
{
transform.Transform(reader, writer);
}
License.LicenseKey = "Liecense-Key";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlFileAsPdf("output.html");
pdf.SaveAs("Report.pdf");using System;
using System.Xml.Xsl;
using System.Xml;
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load("style.xslt");
XmlReader reader = XmlReader.Create("data.xml");
XmlWriterSettings settings = new XmlWriterSettings { Indent = true, OmitXmlDeclaration = true };
using (XmlWriter writer = XmlWriter.Create("output.html", settings))
{
transform.Transform(reader, writer);
}
License.LicenseKey = "Liecense-Key";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlFileAsPdf("output.html");
pdf.SaveAs("Report.pdf");Sie beginnen mit einem XSLT-Stylesheet (style.xslt), das vorschreibt, wie die XML-Daten als HTML strukturiert werden sollen. Die Klasse XslCompiledTransform in .NET wird verwendet, um Ihre XSLT-Datei zu laden.
Verwenden Sie XmlReader, um Ihre XML-Daten (data.xml) zu laden. XmlReader ist effizient für diesen Zweck, da es eine nur vorwärts gerichtete, schreibgeschützte Ansicht der XML-Daten bietet.
Der umgewandelte HTML-Code wird mit XmlWriter in eine Datei (output.html) geschrieben, die so konfiguriert ist, dass sie zur besseren Lesbarkeit eingerücktes HTML erzeugt und die XML-Deklaration weglässt, da diese im HTML-Ausgang nicht benötigt wird.
Mit der HTML-Datei bereit, wird IronPDF's ChromePdfRenderer verwendet, um das HTML-Dokument in ein PDF zu konvertieren. Dieser Renderer ahmt eine hochwertige Rendering-Engine nach und stellt sicher, dass die generierte PDF-Datei den HTML-Inhalt genau wiedergibt.
Schließlich wird das PDF-Dokument im Dateisystem gespeichert (Report.pdf). Mit diesem Schritt ist der Konvertierungsprozess abgeschlossen. Das Ergebnis ist ein PDF-Dokument, das von den ursprünglichen XML-Daten abgeleitet ist.
So erstellen wir Berichte mit XML und IronPDF. Die PDF-Ausgabedatei, die wir erzeugen:
Wir können interaktive SAP-Berichte auch programmatisch erstellen und sie dann mit IronPDF konvertieren. Für eine detailliertere Anleitung folgen Sie diesem Leitfaden zur C# Berichtserstellung.
Report.NET bietet eine Reihe von fortgeschrittenen Funktionen, die eine umfassende PDF-Erstellung und -Anpassung ermöglichen. Die in der Abbildung aufgeführten Funktionen spiegeln einige dieser erweiterten Möglichkeiten wider. Lassen Sie uns jede einzelne davon im Detail betrachten.
Diese Funktion ermöglicht die Verwendung verschiedener Schriftarten und -größen in einem PDF-Dokument. Damit können Entwickler das Erscheinungsbild verschiedener Schriftarten testen und sicherstellen, dass der Text korrekt und gemäß den Designvorgaben angezeigt wird.
using Root.Reports;
using System;
using System.Drawing;
namespace ReportSamples {
public class Test : Report {
private readonly FontDef fontDef;
private readonly FontProp fontProp_Title;
private readonly FontProp fontProp_Label;
public Test() {
fontDef = FontDef.FontDefFromName(this, FontDef.StandardFont.Helvetica);
fontProp_Title = new FontPropMM(fontDef, 6) { Bold = true };
fontProp_Label = new FontPropMM(fontDef, 4);
}
protected override void Create() {
FontTest();
}
private void FontTest() {
FontProp fp_Title = new FontPropMM(fontDef, 12) { Bold = true };
FontProp fp = new FontPropMM(fontDef, 6);
FontProp fp_Small = new FontPropMM(fontDef, 1.4);
FontProp fp_XSmall = new FontPropMM(fontDef, 0.8);
Page page_Cur = new Page(this);
page_Cur.AddCB_MM(30, new RepString(fontProp_Title, "Font Test"));
Double rX = 300;
Double rY = 40;
for (Int32 i = 32; i < 127; i++) {
PrintCharacter(i, fp, fp_Small, fp_XSmall, rX, rY, page_Cur);
}
for (Int32 i = 161; i < 256; i++) {
PrintCharacter(i, fp, fp_Small, fp_XSmall, rX, rY, page_Cur);
}
PrintCharacter('�', fp, fp_Small, fp_XSmall, rX, rY, page_Cur);
}
private void PrintCharacter(Int32 iChar, FontProp fp, FontProp fp_Small, FontProp fp_XSmall, Double rX, Double rY, Page page_Cur) {
if (rX > 185) {
rY += fp.rLineFeedMM;
rX = 22;
}
if (rY > 280) {
new Page(this);
rY = 40;
}
Char ch = (Char)iChar;
String s = ch.ToString();
page_Cur.AddMM(rX + 2, rY, new RepString(fp, s));
rX += 15;
}
}
}using Root.Reports;
using System;
using System.Drawing;
namespace ReportSamples {
public class Test : Report {
private readonly FontDef fontDef;
private readonly FontProp fontProp_Title;
private readonly FontProp fontProp_Label;
public Test() {
fontDef = FontDef.FontDefFromName(this, FontDef.StandardFont.Helvetica);
fontProp_Title = new FontPropMM(fontDef, 6) { Bold = true };
fontProp_Label = new FontPropMM(fontDef, 4);
}
protected override void Create() {
FontTest();
}
private void FontTest() {
FontProp fp_Title = new FontPropMM(fontDef, 12) { Bold = true };
FontProp fp = new FontPropMM(fontDef, 6);
FontProp fp_Small = new FontPropMM(fontDef, 1.4);
FontProp fp_XSmall = new FontPropMM(fontDef, 0.8);
Page page_Cur = new Page(this);
page_Cur.AddCB_MM(30, new RepString(fontProp_Title, "Font Test"));
Double rX = 300;
Double rY = 40;
for (Int32 i = 32; i < 127; i++) {
PrintCharacter(i, fp, fp_Small, fp_XSmall, rX, rY, page_Cur);
}
for (Int32 i = 161; i < 256; i++) {
PrintCharacter(i, fp, fp_Small, fp_XSmall, rX, rY, page_Cur);
}
PrintCharacter('�', fp, fp_Small, fp_XSmall, rX, rY, page_Cur);
}
private void PrintCharacter(Int32 iChar, FontProp fp, FontProp fp_Small, FontProp fp_XSmall, Double rX, Double rY, Page page_Cur) {
if (rX > 185) {
rY += fp.rLineFeedMM;
rX = 22;
}
if (rY > 280) {
new Page(this);
rY = 40;
}
Char ch = (Char)iChar;
String s = ch.ToString();
page_Cur.AddMM(rX + 2, rY, new RepString(fp, s));
rX += 15;
}
}
}
Mit der Funktion Bildmuster können Entwickler Bilder in PDF-Dokumente einbetten. Dazu gehören die Steuerung der Größe und Positionierung der Bilder sowie die mögliche Anwendung von Transformationen oder Effekten auf sie.
using Root.Reports;
using System.Drawing;
namespace ReportSamples {
public class ImageSample : Report {
protected override void Create() {
FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
FontProp fp_Title = new FontPropMM(fd, 15) { Bold = true };
FontProp fp_SubTitle = new FontPropMM(fd, 4) { Bold = true };
PenProp pp = new PenProp(this, 0.2, Color.FromArgb(235, 235, 235));
PenProp pp_Black = new PenProp(this, 0.2, Color.Black);
BrushProp bp = new BrushProp(this, Color.LightGray);
new Page(this);
page_Cur.AddCB_MM(40, new RepString(fp_Title, "Image Sample"));
System.IO.Stream stream = GetType().Assembly.GetManifestResourceStream("ReportSamples.Image.jpg");
page_Cur.AddMM(20, 90, new RepImageMM(stream, 40, Double.NaN));
page_Cur.AddMM(20, 95, new RepString(fp_SubTitle, "W = 40mm, H = auto."));
page_Cur.AddMM(67, 90, new RepImageMM(stream, 40, 20));
page_Cur.AddMM(67, 95, new RepString(fp_SubTitle, "W = 40mm, H = 20mm"));
page_Cur.AddMM(114, 90, new RepImageMM(stream, Double.NaN, 30));
page_Cur.AddMM(114, 95, new RepString(fp_SubTitle, "W = auto., H = 30mm"));
page_Cur.AddMM(161, 90, new RepImageMM(stream, 30, 30));
page_Cur.AddMM(161, 95, new RepString(fp_SubTitle, "W = 30mm, H = 30mm"));
}
}
}using Root.Reports;
using System.Drawing;
namespace ReportSamples {
public class ImageSample : Report {
protected override void Create() {
FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
FontProp fp_Title = new FontPropMM(fd, 15) { Bold = true };
FontProp fp_SubTitle = new FontPropMM(fd, 4) { Bold = true };
PenProp pp = new PenProp(this, 0.2, Color.FromArgb(235, 235, 235));
PenProp pp_Black = new PenProp(this, 0.2, Color.Black);
BrushProp bp = new BrushProp(this, Color.LightGray);
new Page(this);
page_Cur.AddCB_MM(40, new RepString(fp_Title, "Image Sample"));
System.IO.Stream stream = GetType().Assembly.GetManifestResourceStream("ReportSamples.Image.jpg");
page_Cur.AddMM(20, 90, new RepImageMM(stream, 40, Double.NaN));
page_Cur.AddMM(20, 95, new RepString(fp_SubTitle, "W = 40mm, H = auto."));
page_Cur.AddMM(67, 90, new RepImageMM(stream, 40, 20));
page_Cur.AddMM(67, 95, new RepString(fp_SubTitle, "W = 40mm, H = 20mm"));
page_Cur.AddMM(114, 90, new RepImageMM(stream, Double.NaN, 30));
page_Cur.AddMM(114, 95, new RepString(fp_SubTitle, "W = auto., H = 30mm"));
page_Cur.AddMM(161, 90, new RepImageMM(stream, 30, 30));
page_Cur.AddMM(161, 95, new RepString(fp_SubTitle, "W = 30mm, H = 30mm"));
}
}
}
Der Listenlayout-Manager bietet eine Möglichkeit, einem PDF-Dokument Listen hinzuzufügen. Dies ist nützlich, um geordnete oder ungeordnete Listen zu erstellen, den Listeneinzug und die Aufzählungszeichenstile anzupassen und das Gesamtlayout der Listenelemente im Dokument zu verwalten.
using Root.Reports;
using System.Drawing;
namespace ReportSamples {
public class ListLayoutManagerSample : Report {
private Double rMarginLeft = 20; // millimeters
private Double rWidth = 175; // millimeters
protected override void Create() {
FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
FontProp fp = new FontPropMM(fd, 1.9);
Double rY = 40; // vertical position in millimeters
new Page(this);
FontProp fp_Title = new FontPropMM(fd, 8);
page_Cur.AddCB_MM(rY, new RepString(fp_Title, "List Layout Manager Sample"));
rY += 18;
ListLayoutManager llm = null;
using (llm = new ListLayoutManager(this)) {
PenProp pp_BorderLine = new PenPropMM(this, 0.4, Color.Blue);
PenProp pp_GridLine = new PenPropMM(this, 0.1, Color.Blue);
// Configuration for columns
TlmColumn col_Number = new TlmColumnMM(llm, 10);
col_Number.tlmCellDef_Default.rAlignH = RepObj.rAlignCenter;
col_Number.tlmCellDef_Default.rAlignV = RepObj.rAlignCenter;
col_Number.tlmCellDef_Default.penProp_LineLeft = pp_BorderLine;
TlmColumn col_Text = new TlmColumnMM(llm, 100);
col_Text.tlmCellDef_Default.tlmTextMode = TlmTextMode.MultiLine;
TlmColumn col_Author = new TlmColumnMM(llm, rWidth - llm.rWidthMM);
col_Author.tlmCellDef_Default.penProp_LineRight = pp_BorderLine;
col_Author.tlmCellDef_Default.brushProp_Back = new BrushProp(this, Color.FromArgb(255, 210, 210));
llm.container_CreateMM(page_Cur, rMarginLeft, rY); // immediately creates a container
// Adding rows and content
// ...
// Rows and content omitted for brevity
// ...
}
rY += llm.rCurY_MM + 1.5;
fp.rSizeMM = 1.5;
page_Cur.AddRT_MM(rMarginLeft + rWidth, rY, new RepString(fp, "End of list"));
}
}
}using Root.Reports;
using System.Drawing;
namespace ReportSamples {
public class ListLayoutManagerSample : Report {
private Double rMarginLeft = 20; // millimeters
private Double rWidth = 175; // millimeters
protected override void Create() {
FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
FontProp fp = new FontPropMM(fd, 1.9);
Double rY = 40; // vertical position in millimeters
new Page(this);
FontProp fp_Title = new FontPropMM(fd, 8);
page_Cur.AddCB_MM(rY, new RepString(fp_Title, "List Layout Manager Sample"));
rY += 18;
ListLayoutManager llm = null;
using (llm = new ListLayoutManager(this)) {
PenProp pp_BorderLine = new PenPropMM(this, 0.4, Color.Blue);
PenProp pp_GridLine = new PenPropMM(this, 0.1, Color.Blue);
// Configuration for columns
TlmColumn col_Number = new TlmColumnMM(llm, 10);
col_Number.tlmCellDef_Default.rAlignH = RepObj.rAlignCenter;
col_Number.tlmCellDef_Default.rAlignV = RepObj.rAlignCenter;
col_Number.tlmCellDef_Default.penProp_LineLeft = pp_BorderLine;
TlmColumn col_Text = new TlmColumnMM(llm, 100);
col_Text.tlmCellDef_Default.tlmTextMode = TlmTextMode.MultiLine;
TlmColumn col_Author = new TlmColumnMM(llm, rWidth - llm.rWidthMM);
col_Author.tlmCellDef_Default.penProp_LineRight = pp_BorderLine;
col_Author.tlmCellDef_Default.brushProp_Back = new BrushProp(this, Color.FromArgb(255, 210, 210));
llm.container_CreateMM(page_Cur, rMarginLeft, rY); // immediately creates a container
// Adding rows and content
// ...
// Rows and content omitted for brevity
// ...
}
rY += llm.rCurY_MM + 1.5;
fp.rSizeMM = 1.5;
page_Cur.AddRT_MM(rMarginLeft + rWidth, rY, new RepString(fp, "End of list"));
}
}
}
Dies bezieht sich auf die Fähigkeit, verschiedene Eigenschaften des PDF-Dokuments selbst festzulegen und zu ändern, wie z.B. Metadaten (Autor, Titel, Thema), Anzeigeeinstellungen und Sicherheitseinstellungen wie Verschlüsselung und Zugriffsberechtigungen.
using Root.Reports;
using System;
namespace ReportSamples {
public class PdfPropertiesSample : Report {
public PdfPropertiesSample() {
PdfFormatter pf = (PdfFormatter)formatter;
pf.sTitle = "PDF Sample";
pf.sAuthor = "Otto Mayer, mot@root.ch";
pf.sSubject = "Sample of some PDF features";
pf.sKeywords = "Sample PDF RSF";
pf.sCreator = "RSF Sample Application";
pf.dt_CreationDate = new DateTime(2002, 8, 15, 0, 0, 0, 0);
pf.pageLayout = PageLayout.TwoColumnLeft;
pf.bHideToolBar = true;
pf.bHideMenubar = false;
pf.bHideWindowUI = true;
pf.bFitWindow = true;
pf.bCenterWindow = true;
pf.bDisplayDocTitle = true;
}
protected override void Create() {
FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
FontProp fp = new FontPropMM(fd, 4);
FontProp fp_Title = new FontPropMM(fd, 11);
fp_Title.bBold = true;
Page page = new Page(this);
page.AddCB_MM(40, new RepString(fp_Title, "PDF Properties Sample"));
fp_Title.rSizeMM = 8;
page.AddCB_MM(100, new RepString(fp_Title, "First Page"));
page.AddCB_MM(120, new RepString(fp, "Choose <Document Properties, Summary> from the"));
page.AddCB_MM(126, new RepString(fp, "File menu to display the document properties"));
page = new Page(this);
page.AddCB_MM(100, new RepString(fp_Title, "Second Page"));
}
}
}using Root.Reports;
using System;
namespace ReportSamples {
public class PdfPropertiesSample : Report {
public PdfPropertiesSample() {
PdfFormatter pf = (PdfFormatter)formatter;
pf.sTitle = "PDF Sample";
pf.sAuthor = "Otto Mayer, mot@root.ch";
pf.sSubject = "Sample of some PDF features";
pf.sKeywords = "Sample PDF RSF";
pf.sCreator = "RSF Sample Application";
pf.dt_CreationDate = new DateTime(2002, 8, 15, 0, 0, 0, 0);
pf.pageLayout = PageLayout.TwoColumnLeft;
pf.bHideToolBar = true;
pf.bHideMenubar = false;
pf.bHideWindowUI = true;
pf.bFitWindow = true;
pf.bCenterWindow = true;
pf.bDisplayDocTitle = true;
}
protected override void Create() {
FontDef fd = new FontDef(this, FontDef.StandardFont.Helvetica);
FontProp fp = new FontPropMM(fd, 4);
FontProp fp_Title = new FontPropMM(fd, 11);
fp_Title.bBold = true;
Page page = new Page(this);
page.AddCB_MM(40, new RepString(fp_Title, "PDF Properties Sample"));
fp_Title.rSizeMM = 8;
page.AddCB_MM(100, new RepString(fp_Title, "First Page"));
page.AddCB_MM(120, new RepString(fp, "Choose <Document Properties, Summary> from the"));
page.AddCB_MM(126, new RepString(fp, "File menu to display the document properties"));
page = new Page(this);
page.AddCB_MM(100, new RepString(fp_Title, "Second Page"));
}
}
}Die Funktion PDF aus Text zeigt die Möglichkeiten der Bibliothek beim Hinzufügen und Anpassen von Textinhalten in einer PDF-Datei. Dazu gehören die Einstellung der Textausrichtung, des Zeilenabstands, der Farbe und die Anwendung von Texteffekten wie Fett- oder Kursivdruck.
IronPDF ist bekannt für seine umfassende und detaillierte Dokumentation. IronPDF bietet einen gut organisierten Dokumentationsbereich mit Einrichtungsanweisungen, Tutorials und API-Referenzen. Die Leitfäden sind so strukturiert, dass sowohl Anfänger als auch erfahrene Entwickler die benötigten Informationen schnell finden können. Für die Unterstützung durch die Gemeinschaft können sich die Entwickler an Foren und Community-Diskussionen wenden. Hier können sie Fragen stellen, Erfahrungen austauschen und Antworten von anderen Nutzern finden.
IronPDF bietet außerdem professionellen Support über ein Ticketing-System, über das Techniker direkt vom IronPDF-Team Hilfe erhalten können. Dieser Dienst kann Teil der kostenpflichtigen Lizenzierung sein, die eine direktere und unmittelbarere Unterstützung bietet.
Report.NET, als Open-Source-Bibliothek, hat einen anderen Ansatz für Dokumentation und Support. Die Dokumentation ist zwar nicht so umfangreich wie bei kommerziellen Bibliotheken, reicht aber für den Einstieg und die Bewältigung gängiger Aufgaben aus. Die Dokumentation der Bibliothek findet sich im GitHub-Repository oder als Inline-Kommentar im Quellcode. Sie sind eher technisch und erfordern möglicherweise eine gewisse Recherche, um die benötigten Informationen zu finden.
Da es sich bei Report.NET um eine freie und quelloffene Bibliothek handelt, bietet sie keine offizielle professionelle Unterstützung. Die Entwickler sind auf die Hilfe der Community angewiesen oder müssen für tiefer gehende Fragen einen Spezialisten beauftragen.
IronPDF bietet eine Vielzahl von Lizenzierungsmodellen an, um den unterschiedlichen Entwicklungs- und Bereitstellungsanforderungen gerecht zu werden und sicherzustellen, dass es eine passende Lösung für Projekte und Organisationen jeder Größe gibt. Hier ist ein Überblick:
Lite License ($749 USD): Dies ist die einfachste Option, geeignet für einzelne Entwickler, die an einem einzelnen Projekt an einem Standort arbeiten. Sie beinhaltet E-Mail-Support, deckt aber nicht die lizenzfreie Weiterverbreitung ab.
Plus License (1.499 USD): Ausgerichtet auf kleine Teams, diese Lizenz unterstützt bis zu drei Entwickler, die an drei Projekten an drei Standorten arbeiten. Es erweitert den Support um einen 24-Stunden-E-Mail- und Chat-Service sowie einen telefonischen Support.
Professional License (2.999 USD): Diese ist für größere Teams und Projekte konzipiert und bietet Platz für bis zu 10 Entwickler an 10 Standorten, die an 10 Projekten arbeiten. Sie enthält alle Plus-Unterstützungsoptionen und bietet zusätzlich Unterstützung für die Bildschirmfreigabe zur interaktiven Problemlösung.
Kostenlose Testlizenz: Ideal für Evaluierungszwecke, ermöglicht diese Testlizenz Ihnen, IronPDF kostenlos auszuprobieren. Sie ist jedoch für den privaten Gebrauch bestimmt, und die erzeugten PDFs sollten nicht auf öffentlichen oder unternehmensinternen Internet- oder Intranetprojekten veröffentlicht werden.
Zusätzlich zu den Basislizenzen gibt es Optionen für eine erweiterte Abdeckung:
Report.NET wird kostenlos unter der LGPL-Lizenz vertrieben. Die LGPL (Lesser General Public License) ist eine freie Softwarelizenz, die es Benutzern erlaubt, die Software auszuführen, zu studieren, zu teilen und zu ändern. Die Lizenz gewährleistet, dass die Report.NET-Bibliothek sowohl in Open-Source- als auch in proprietärer Software frei verwendet werden kann, solange die LGPL-lizenzierten Teile des Codes nicht verändert werden. Wenn sie geändert werden, müssen diese Änderungen unter derselben Lizenz weitergegeben werden.
Bei der Betrachtung von IronPDF und Report.NET haben wir verschiedene Elemente wie ihre Fähigkeiten, den Funktionsumfang, die Benutzerfreundlichkeit, die Supportdienste und die Art der Lizenzierung untersucht.
IronPDF bietet eine umfangreiche Reihe von Funktionen, die es Entwicklern ermöglichen, nicht nur PDF-Dateien aus HTML, Bildern und Text zu erstellen und zu bearbeiten, sondern auch erweiterte Funktionen wie Verschlüsselung, digitale Signaturen und maßgeschneiderte Kopf- und Fußzeilen zu implementieren. Durch die Unterstützung verschiedener Lizenzen eignet sich das Programm für Projekte unterschiedlicher Größe, vom Einzelentwickler bis zum Großunternehmen. Dank der umfassenden Dokumentation und der professionellen Supportstruktur eignet sich das Programm für Projekte, bei denen es auf ständige Aktualisierungen und direkte Unterstützung ankommt. IronPDF bietet auch eine kostenlose Testversion von IronPDF, die ab $749 beginnt.
Report.NET hingegen ist ein einfaches Werkzeug, das PDF-Dokumente erzeugen kann. Die LGPL-Lizenz bedeutet, dass es für Entwickler ohne nennenswerte Einschränkungen sowohl in privaten als auch in kommerziellen Projekten eingesetzt werden kann. Auch wenn es nicht das gleiche Maß an strukturierter Unterstützung wie IronPDF bietet, fördert der Open-Source-Charakter von Report.NET den Input und die Hilfe der Community.
Ihre Entscheidung zwischen IronPDF und Report.NET wird von den spezifischen Anforderungen Ihres Projekts abhängen. Wenn Ihr Projekt detaillierte PDF-Erstellung und -Bearbeitung mit professioneller Unterstützung erfordert, könnte IronPDF die erste Wahl sein.
Install-Package IronPdf
Keine Kreditkarte erforderlich
Ihr Testschlüssel sollte in der E-Mail sein.
Wenn nicht, kontaktieren Sie bitte
support@ironsoftware.com
Keine Kreditkarte erforderlich
Starten Sie kostenlos
Keine Kreditkarte erforderlich
Testen Sie in der Produktion ohne Wasserzeichen.
Funktioniert überall, wo Sie es benötigen.
Erhalten Sie 30 Tage lang ein voll funktionsfähiges Produkt.
Haben Sie es in wenigen Minuten einsatzbereit.
Vollständiger Zugang zu unserem technischen Support-Team während Ihrer Produkttestphase
Keine Kreditkarte oder Kontoerstellung erforderlich
Ihr Testschlüssel sollte sich in der E-Mail befinden.
Falls nicht, kontaktieren Sie bitte
support@ironsoftware.com
Starten Sie kostenlos
Keine Kreditkarte erforderlich
Testen Sie in der Produktion ohne Wasserzeichen.
Funktioniert überall, wo Sie es benötigen.
Erhalten Sie 30 Tage lang ein voll funktionsfähiges Produkt.
Haben Sie es in wenigen Minuten einsatzbereit.
Vollständiger Zugang zu unserem technischen Support-Team während Ihrer Produkttestphase
Lizenzen ab $749. Haben Sie eine Frage? Kontaktieren Sie uns.
Buchen Sie eine persönliche 30-minütige Demo.
Kein Vertrag, keine Kartendetails, keine Verpflichtungen.
10 .NET API-Produkte für Ihre Bürodokumente
