Ein Vergleich zwischen Report .NET und IronPDF

1.1.1 Erstellung und Bearbeitung von Dokumenten

Report.NET glänzt bei der Erstellung neuer PDF-Dokumente und der Bearbeitung bestehender. Entwickler können problemlos Text, Bilder und Grafiken hinzufügen und so detaillierte und optisch ansprechende Dokumente erstellen.

1.1.2 Flexibilität bei der Inhaltsverwaltung

Diese Bibliothek ermöglicht eine präzise Kontrolle über den Inhalt des Dokuments, einschließlich Textformatierung, Bildplatzierung und grafischen Elementen. Dieses Maß an Kontrolle stellt sicher, dass das endgültige PDF genau so aussieht, wie beabsichtigt.

1.1.3 Benutzerfreundlichkeit

Mit einem Fokus auf Einfachheit vereinfacht Report.NET den PDF-Generierungsprozess und macht ihn auch für diejenigen zugänglich, die neu im Umgang mit PDFs im Programmierkontext sind.

1.1.4 Kompatibilität über Plattformen hinweg

Report.NET ist so konzipiert, dass es nahtlos über die .NET-Plattform, einschließlich .NET Core, funktioniert und sicherstellt, dass Anwendungen PDFs unabhängig vom Betriebssystem erzeugen und verwalten können.

1.1.5 Anpassung und Styling

Die Bibliothek bietet umfangreiche Anpassungsoptionen für PDF-Dokumente und ermöglicht es Entwicklern, Layout, Styling und Gesamtoptik an ihre spezifischen Bedürfnisse anzupassen.

1.1.6 Offene Quellen

Als Open-Source-Tool profitiert Report.NET von Beiträgen aus der Gemeinschaft, die dafür sorgen, dass es auf dem neuesten Stand bleibt und im Laufe der Zeit neue Funktionen erhält. Diese Unterstützung aus der Gemeinschaft bedeutet auch, dass Entwickler auf eine Fülle von Wissen und Ressourcen zugreifen können.

2.1.1 Konvertierung von HTML in PDF

Einer der Hauptvorteile von IronPDF ist seine Fähigkeit, HTML und CSS in PDF-Dokumente zu konvertieren. Diese Funktion ist für Entwickler, die Webinhalte in ein portables Format umwandeln möchten, von unschätzbarem Wert, während das ursprüngliche Design und Layout erhalten bleiben.

2.1.2 PDF-Bearbeitung

IronPDF glänzt darin, Entwicklern Werkzeuge zur Bearbeitung und Manipulation von PDF-Dokumenten bereitzustellen. Dies beinhaltet das Hinzufügen oder Entfernen von Seiten, das Ändern von Text und das Einbetten von Bildern. Wir können auch Berichtsdaten aus den Berichten mit IronPDF extrahieren.

2.1.3 Formularverarbeitung

Die Bibliothek unterstützt die Erstellung und Bearbeitung von PDF-Formularen, die es Benutzern ermöglichen, auf dynamische Weise mit Dokumenten zu interagieren. Diese Funktionalität ist entscheidend für Anwendungen, die Eingaben von Endnutzern erfordern, wie Umfragen oder Antragsformulare.

2.1.4 Sicherheitsmerkmale

Mit IronPDF ist die Implementierung von Sicherheitsmaßnahmen wie Verschlüsselung und Passwortschutz unkompliziert. Diese Funktionen stellen sicher, dass sensible Informationen innerhalb von PDF-Dokumenten vor unbefugtem Zugriff geschützt bleiben.

2.1.5 Drucken und Rendering

IronPDF ermöglicht es Entwicklern, PDFs sowohl für die Bildschirmansicht als auch für den physischen Druck zu rendern, was in beiden Fällen eine hohe Ausgabequalität sicherstellt. Dies erleichtert die Vorbereitung von Dokumenten für eine Vielzahl von Präsentations- oder Vertriebsbedürfnissen.

2.1.6 Plattformübergreifende Unterstützung

IronPDF funktioniert über verschiedene .NET-Plattformen hinweg, hält sich dabei an .NET-Code-Standards und erleichtert die Entwicklung in verschiedenen Umgebungen ohne Kompatibilitätsprobleme.

2.1.7 Umfassende Dokumentation und Unterstützung

IronPDF wird unterstützt durch ausführliche Dokumentation und engagierten Support, der Entwicklern hilft, sich in den Funktionen der Bibliothek zurechtzufinden und ihre Funktionalitäten effizient in ihre Anwendungen zu integrieren.

2.1.8 Erweiterte PDF-Bearbeitung

IronPDF bietet viele erweiterte Bearbeitungsfunktionen. Dies umfasst die Möglichkeit, PDF-Dokumente zu verbinden und zu trennen, was besonders nützlich ist, um große Informationsmengen zu organisieren oder spezifische Abschnitte aus einem Dokument für die separate Nutzung zu extrahieren.

2.1.9 Benutzerdefinierte Kopf- und Fußzeilen

Die Bibliothek ermöglicht die Anpassung von Kopf- und Fußzeilen innerhalb von PDF-Dokumenten. Diese Fähigkeit ist wichtig für das Hinzufügen von konsistentem Branding, Seitennummern oder Dokumenttiteln über die Seiten hinweg, um das professionelle Erscheinungsbild des Outputs zu verbessern.

IronPDF verfügt über eine Reihe erweiterter Funktionen, die darauf ausgelegt sind, ein breites Spektrum an PDF-bezogenen Aufgaben mühelos zu bewältigen.

6.1.1 HTML zu PDF Rendering

IronPDF kann HTML-Inhalte, einschließlich CSS und JavaScript, direkt in ein PDF-Dokument rendern. Das bedeutet, dass Webseiten oder HTML-Templates in PDFs umgewandelt werden können, die genauso aussehen wie im Browser.

6.1.1.1 HTML-String in PDF

IronPDF ermöglicht die direkte Konvertierung von HTML-Strings in PDF. Das bedeutet, dass Entwickler HTML-Code, der als String-Variable gespeichert ist, verwenden können, um ihn mit IronPDF in eine PDF-Datei zu rendern. Diese Funktion ist besonders nützlich, wenn der HTML-Inhalt dynamisch generiert oder von der Anwendung vor der Umwandlung geändert wurde.

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");

Imports IronPdf
Private Renderer = New IronPdf.HtmlToPdf()
Private PDF = Renderer.RenderHtmlAsPdf("<h1>Hello IronPDF</h1>")
PDF.SaveAs("HtmlStringToPdf.pdf")

6.1.1.2 HTML-Datei zu PDF

Ebenso kann IronPDF bestehende HTML-Dateien in PDF-Dokumente umwandeln. Dies erfolgt durch das Einlesen der HTML-Datei aus dem Dateisystem und die Verwendung von IronPDF zur Erstellung eines PDF-Dokuments mit gleichem Format und Struktur.

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");

Imports IronPdf
Private Renderer = New ChromePdfRenderer()
Private PDF = Renderer.RenderHTMLFileAsPdf("invoice.html")
PDF.SaveAs("HtmlFileToPdf.pdf")

6.1.1.3 URL zu PDF

IronPDF ist auch in der Lage, ein PDF aus einer Live-URL zu rendern. Dies ermöglicht es Entwicklern, eine Webadresse einzugeben, und IronPDF ruft den HTML-Inhalt von der URL ab 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");

Imports IronPdf
Private Renderer = New ChromePdfRenderer()
Private PDF = Renderer.RenderUrlAsPdf("http://ironpdf.com")
PDF.SaveAs("UrlToPdf.pdf")

6.1.2 Bearbeiten von PDFs

Mit IronPDF können Sie bestehende PDF-Dokumente bearbeiten. Dies umfasst 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");

Imports IronPdf
Private document = PdfDocument.FromFile("original_document.pdf")
Private Const targetPageIndex As Integer = 1
Private Const oldString As String = "Hello, World!"
Private Const newString As String = "Greetings, Universe!"
document.ReplaceTextOnPage(targetPageIndex, oldString, newString)
document.SaveAs("modified_document.pdf")

6.1.3 Text und Bilder extrahieren

Diese Bibliothek kann Text und Bilder aus PDF-Dateien extrahieren, ähnlich wie Crystal Reports, die Sie zum Indizieren, Suchen oder Wiederverwenden von Inhalten verwenden können.

6.1.4 PDF-Formulare generieren

IronPDF unterstützt die Erstellung von PDF-Formularen. Entwickler können programmatisch Formulare innerhalb eines PDF erstellen, und Benutzer können sie ausfüllen.

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");

Imports IronPdf
Imports System
Private Const alternativeHtmlContent As String = "
    <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>"
Private alternativePdfRenderer = New ChromePdfRenderer()
alternativePdfRenderer.RenderingOptions.CreatePdfFormsFromHtml = True
alternativePdfRenderer.RenderHtmlAsPdf(alternativeHtmlContent).SaveAs("AlternativeForm.pdf")

6.1.5 Zusammenführen von PDF-Dokumenten

Sie können mehrere PDF-Dateien zu einem einzigen Dokument kombinieren. Diese Funktion ist praktisch zum Konsolidieren von Berichten oder zum Kombinieren verschiedener Dokumentabschnitte.

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");

Imports IronPdf
Private 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>"
Private 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>"
Private pdfRenderer = New ChromePdfRenderer()
Private pdfDocA = pdfRenderer.RenderHtmlAsPdf(firstHtmlContent)
Private pdfDocB = pdfRenderer.RenderHtmlAsPdf(secondHtmlContent)
Private mergedPdf = PdfDocument.Merge(pdfDocA, pdfDocB)
mergedPdf.SaveAs("MergedDocuments.pdf")

6.1.6 PDF-Dokumente aufteilen

Umgekehrt kann IronPDF ein einzelnes PDF in mehrere Dokumente aufteilen. Dies könnte erforderlich sein, wenn Sie einzelne Seiten oder Abschnitte verteilen möchten.

6.1.7 Verschlüsseln und Entschlüsseln von PDFs

IronPDF ermöglicht die Verschlüsselung und Entschlüsselung von PDF-Dokumenten, was eine zusätzliche Sicherheitsschicht für sensible Informationen bietet.

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");

Imports IronPdf
Imports System
Private encryptedPdf = PdfDocument.FromFile("protected.pdf", "password")
encryptedPdf.SecuritySettings.RemovePasswordsAndEncryption()
encryptedPdf.SecuritySettings.MakePdfDocumentReadOnly("super-secret-key")
encryptedPdf.Password = "new-password"
encryptedPdf.SaveAs("secured.pdf")

6.1.8 Dokumenteigenschaften und Metadaten festlegen

Mit dieser Bibliothek ist das Festlegen von Dokumenteigenschaften wie Titel, Autor und Metadaten unkompliziert. Dies hilft bei der Dokumentenverwaltung und -organisation.

using IronPdf;
using System;
var encryptedPdf = PdfDocument.FromFile("sample.pdf");
encryptedPdf.MetaData.Author = "Iron Developer";
encryptedPdf.MetaData.Keywords = "Confidential, Private";
encryptedPdf.MetaData.ModifiedDate = DateTime.Now;
encryptedPdf.SaveAs("modified.pdf");

using IronPdf;
using System;
var encryptedPdf = PdfDocument.FromFile("sample.pdf");
encryptedPdf.MetaData.Author = "Iron Developer";
encryptedPdf.MetaData.Keywords = "Confidential, Private";
encryptedPdf.MetaData.ModifiedDate = DateTime.Now;
encryptedPdf.SaveAs("modified.pdf");

Imports IronPdf
Imports System
Private encryptedPdf = PdfDocument.FromFile("sample.pdf")
encryptedPdf.MetaData.Author = "Iron Developer"
encryptedPdf.MetaData.Keywords = "Confidential, Private"
encryptedPdf.MetaData.ModifiedDate = DateTime.Now
encryptedPdf.SaveAs("modified.pdf")

6.1.9 PDF/A-Konformität

IronPDF kann PDF/A-kompatible Dokumente generieren, die für langfristige Archivierungs- und Aufzeichnungszwecke erforderlich sind.

6.1.10 XML-Berichte mit IronPDF

Die direkte Konvertierung von XML in PDF wird von IronPDF nicht unterstützt, aber ein gangbarer Ansatz besteht darin, XML-Daten zuerst in HTML-Format umzuwandeln. Dies wird durch den Einsatz von XSLT (Extensible Stylesheet Language Transformations) erreicht, einer leistungsstarken XML-Stylesheet-Sprache, die dazu dient, XML-Dokumente in andere Formate wie HTML, Text oder sogar ein neues XML-Dokument umzuwandeln. Angenommen, das ist unsere data.xml-Datei:

<?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>

<?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>

<?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>

Hier ist der Code-Ausschnitt, wie wir diesen Ansatz umsetzen 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");

Imports System
Imports System.Xml.Xsl
Imports System.Xml
Private transform As New XslCompiledTransform()
transform.Load("style.xslt")
Dim reader As XmlReader = XmlReader.Create("data.xml")
Dim settings As New XmlWriterSettings With {
	.Indent = True,
	.OmitXmlDeclaration = True
}
Using writer As XmlWriter = XmlWriter.Create("output.html", settings)
	transform.Transform(reader, writer)
End Using
License.LicenseKey = "Liecense-Key"
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlFileAsPdf("output.html")
pdf.SaveAs("Report.pdf")

1. Sie beginnen mit einem XSLT-Stylesheet (style.xslt), das vorgibt, wie die XML-Daten als HTML strukturiert werden sollen. Die XslCompiledTransform-Klasse in .NET wird verwendet, um Ihre XSLT-Datei zu laden.
2. Verwenden Sie XmlReader, um Ihre XML-Daten (data.xml) zu laden. XmlReader ist effizient für diesen Zweck, da es eine vorwärtsgerichtete, schreibgeschützte Ansicht der XML-Daten bereitstellt.
3. Das transformierte HTML wird mit XmlWriter in eine Datei (output.html) geschrieben, die so konfiguriert ist, dass sie eingerücktes HTML für bessere Lesbarkeit produziert und die XML-Deklaration weglässt, die im HTML-Ausgang nicht benötigt wird.
4. Mit der HTML-Datei bereit, wird IronPDF's ChromePdfRenderer verwendet, um das HTML-Dokument in ein PDF umzuwandeln. Dieser Renderer imitiert eine hochwertige Rendering-Engine und stellt sicher, dass das generierte PDF den HTML-Inhalt genau wiedergibt.
5. Schließlich wird das PDF-Dokument im Dateisystem gespeichert (Report.pdf). Dieser Schritt schließt den Konvertierungsprozess ab und ergibt ein PDF-Dokument, das aus den ursprünglichen XML-Daten abgeleitet ist.

So generieren wir Berichte mit XML und IronPDF. Die Ausgabe-PDF-Datei, die wir generieren:

Wir können auch interaktive SAP-Berichte programmatisch erstellen und dann mit IronPDF umwandeln. Für detailliertere Anleitungen folgen Sie diesem Leitfaden zu C# Berichtserstellung.

Report.NET bietet eine Reihe erweiterter Funktionen, die eine umfassende PDF-Erzeugung und -Anpassung ermöglichen. Die in dem Bild aufgeführten Funktionen spiegeln einige dieser erweiterten Fähigkeiten wider. Lassen Sie uns jeden im Detail betrachten.

6.2.1 Hinzufügen von Schriftarten

Diese Funktion ermöglicht die Verwendung verschiedener Schriftstile und -größen innerhalb eines PDF-Dokuments. Entwickler können damit das Aussehen verschiedener Schriften 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;
    }
  }
}

Imports Root.Reports
Imports System
Imports System.Drawing
Namespace ReportSamples
  Public Class Test
	  Inherits Report

	Private ReadOnly fontDef As FontDef
	Private ReadOnly fontProp_Title As FontProp
	Private ReadOnly fontProp_Label As FontProp
	Public Sub New()
	  fontDef = FontDef.FontDefFromName(Me, FontDef.StandardFont.Helvetica)
	  fontProp_Title = New FontPropMM(fontDef, 6) With {.Bold = True}
	  fontProp_Label = New FontPropMM(fontDef, 4)
	End Sub
	Protected Overrides Sub Create()
	  FontTest()
	End Sub
	Private Sub FontTest()
	  Dim fp_Title As FontProp = New FontPropMM(fontDef, 12) With {.Bold = True}
	  Dim fp As FontProp = New FontPropMM(fontDef, 6)
	  Dim fp_Small As FontProp = New FontPropMM(fontDef, 1.4)
	  Dim fp_XSmall As FontProp = New FontPropMM(fontDef, 0.8)
	  Dim page_Cur As New Page(Me)
	  page_Cur.AddCB_MM(30, New RepString(fontProp_Title, "Font Test"))
	  Dim rX As Double = 300
	  Dim rY As Double = 40
	  For i As Int32 = 32 To 126
		PrintCharacter(i, fp, fp_Small, fp_XSmall, rX, rY, page_Cur)
	  Next i
	  For i As Int32 = 161 To 255
		PrintCharacter(i, fp, fp_Small, fp_XSmall, rX, rY, page_Cur)
	  Next i
	  PrintCharacter(AscW(" "c), fp, fp_Small, fp_XSmall, rX, rY, page_Cur)
	End Sub
	Private Sub PrintCharacter(ByVal iChar As Int32, ByVal fp As FontProp, ByVal fp_Small As FontProp, ByVal fp_XSmall As FontProp, ByVal rX As Double, ByVal rY As Double, ByVal page_Cur As Page)
	  If rX > 185 Then
		rY += fp.rLineFeedMM
		rX = 22
	  End If
	  If rY > 280 Then
		Dim tempVar As New Page(Me)
		rY = 40
	  End If
	  Dim ch As Char = ChrW(iChar)
	  Dim s As String = ch.ToString()
	  page_Cur.AddMM(rX + 2, rY, New RepString(fp, s))
	  rX += 15
	End Sub
  End Class
End Namespace

6.2.2 Bildeinbettung

Mit der Funktion "Bildbeispiel" können Entwickler Bilder in PDF-Dokumente einfügen. Dies beinhaltet die Kontrolle der Größe und Positionierung der Bilder sowie möglicherweise die 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"));
    }
  }
}

Imports Root.Reports
Imports System.Drawing
Namespace ReportSamples
  Public Class ImageSample
	  Inherits Report

	Protected Overrides Sub Create()
	  Dim fd As New FontDef(Me, FontDef.StandardFont.Helvetica)
	  Dim fp_Title As FontProp = New FontPropMM(fd, 15) With {.Bold = True}
	  Dim fp_SubTitle As FontProp = New FontPropMM(fd, 4) With {.Bold = True}
	  Dim pp As New PenProp(Me, 0.2, Color.FromArgb(235, 235, 235))
	  Dim pp_Black As New PenProp(Me, 0.2, Color.Black)
	  Dim bp As New BrushProp(Me, Color.LightGray)
	  Dim tempVar As New Page(Me)
	  page_Cur.AddCB_MM(40, New RepString(fp_Title, "Image Sample"))
	  Dim stream As System.IO.Stream = Me.GetType().Assembly.GetManifestResourceStream("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"))
	End Sub
  End Class
End Namespace

6.2.3 Listenlayout-Manager

Der Listenlayout-Manager bietet eine Möglichkeit, Listen zu einem PDF-Dokument hinzuzufügen. Dies ist nützlich zur Erstellung von geordneten oder ungeordneten Listen, zur Anpassung der Listeneinrückung, der Aufzählungszeichenstile, und zur Verwaltung des gesamten Layouts der Listenelemente innerhalb des Dokuments.

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"));
    }
  }
}

Imports Root.Reports
Imports System.Drawing
Namespace ReportSamples
  Public Class ListLayoutManagerSample
	  Inherits Report

	Private rMarginLeft As Double = 20 ' millimeters
	Private rWidth As Double = 175 ' millimeters
	Protected Overrides Sub Create()
	  Dim fd As New FontDef(Me, FontDef.StandardFont.Helvetica)
	  Dim fp As FontProp = New FontPropMM(fd, 1.9)
	  Dim rY As Double = 40 ' vertical position in millimeters
	  Dim tempVar As New Page(Me)
	  Dim fp_Title As FontProp = New FontPropMM(fd, 8)
	  page_Cur.AddCB_MM(rY, New RepString(fp_Title, "List Layout Manager Sample"))
	  rY += 18
	  Dim llm As ListLayoutManager = Nothing
	  llm = New ListLayoutManager(Me)
	  Using llm
		Dim pp_BorderLine As PenProp = New PenPropMM(Me, 0.4, Color.Blue)
		Dim pp_GridLine As PenProp = New PenPropMM(Me, 0.1, Color.Blue)
		' Configuration for columns
		Dim col_Number As TlmColumn = 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
		Dim col_Text As TlmColumn = New TlmColumnMM(llm, 100)
		col_Text.tlmCellDef_Default.tlmTextMode = TlmTextMode.MultiLine
		Dim col_Author As TlmColumn = New TlmColumnMM(llm, rWidth - llm.rWidthMM)
		col_Author.tlmCellDef_Default.penProp_LineRight = pp_BorderLine
		col_Author.tlmCellDef_Default.brushProp_Back = New BrushProp(Me, 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
		' ...
	  End Using
	  rY += llm.rCurY_MM + 1.5
	  fp.rSizeMM = 1.5
	  page_Cur.AddRT_MM(rMarginLeft + rWidth, rY, New RepString(fp, "End of list"))
	End Sub
  End Class
End Namespace

6.2.4 PDF-Eigenschaften

Dies bezieht sich auf die Möglichkeit, verschiedene Eigenschaften des PDF-Dokuments selbst festzulegen und zu ändern, wie 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"));
    }
  }
}

Imports Root.Reports
Imports System
Namespace ReportSamples
  Public Class PdfPropertiesSample
	  Inherits Report

	Public Sub New()
	  Dim pf As PdfFormatter = CType(formatter, PdfFormatter)
	  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
	End Sub
	Protected Overrides Sub Create()
	  Dim fd As New FontDef(Me, FontDef.StandardFont.Helvetica)
	  Dim fp As FontProp = New FontPropMM(fd, 4)
	  Dim fp_Title As FontProp = New FontPropMM(fd, 11)
	  fp_Title.bBold = True
	  Dim page As New Page(Me)
	  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(Me)
	  page.AddCB_MM(100, New RepString(fp_Title, "Second Page"))
	End Sub
  End Class
End Namespace

6.2.5 PDF aus Text

Die Funktion "PDF aus Text" zeigt die Fähigkeiten der Bibliothek bei der Hinzufügung und Anpassung von Textinhalten in einem PDF. Dies umfasst das Festlegen der Textausrichtung, des Zeilenabstands, der Farbe und das Anwenden von Texteffekten wie fett oder kursiv.