The C# PDF Library
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 this article, we'll be taking a close look at two popular C# libraries used for working with PDF files: IronPDF - The .NET PDF Library for C# Developers and Report.NET. These tools are essential for developers who need to create, modify, or interact with PDF documents through their C# applications. Both libraries offer a range of functionalities designed to make handling PDFs easier and more efficient, but they do so in different ways.
IronPDF and Report.NET enable developers to dynamically generate documents, edit content, and pull text and images from PDFs. They also support form processing, adding digital signatures, and ensuring that applications can handle PDFs across different platforms without losing document fidelity. This means that no matter the device or operating system, the PDFs will look and function as intended.
Throughout this comparison, we will dive into the specific features each library offers, how they function, provide code snippets to illustrate how they can be used, and discuss their licensing terms. This comparison aims to give developers a clear understanding of what each library can do, helping them decide which one might be the best fit for their project requirements. Let's break down the capabilities and differences between IronPDF and Report.NET, focusing on simplicity and practical insights for developers.
Report.NET is a robust C# library designed to help developers create, manage, and manipulate PDF documents directly within their .NET applications. This tool is known for its straightforward approach to PDF generation and manipulation, allowing for the creation of complex PDF documents from scratch or the modification of existing ones. Its capabilities range from simple text addition to the incorporation of images and shapes, making it a versatile choice for developers looking to implement PDF functionalities in their projects.
Report.NET shines in creating new PDF documents and editing existing ones. Developers can easily add text, images, and graphics, enabling the production of detailed and visually appealing documents.
This library allows for precise control over the document's content, including text formatting, image placement, and graphic elements. This level of control ensures that the final PDF looks exactly as intended.
With a focus on simplicity, Report.NET simplifies the PDF generation process, making it accessible even to those new to working with PDFs in a programming context.
Report.NET is designed to work seamlessly across the .NET platform, including .NET Core, ensuring that applications can generate and manage PDFs regardless of the operating system.
The library offers extensive customization options for PDF documents, allowing developers to adjust the layout, styling, and overall appearance to meet their specific needs.
As an open-source tool, Report.NET benefits from community contributions, ensuring it stays updated and receives new features over time. This community support also means developers can access a wealth of knowledge and resources.
IronPDF is a comprehensive .NET library crafted to facilitate the creation, manipulation, and rendering of PDF documents within .NET applications. This tool stands out for its ability to handle both the generation of PDFs from HTML and the direct editing of existing PDF files. It is very helpful to create reports. IronPDF also integrates smoothly with SQL Server Reporting Services. We can create an end-user report designer with IronPDF to create a reporting tool and report viewer.
One of the core strengths of IronPDF is its capability to convert HTML and CSS into PDF documents. This feature is invaluable for developers looking to transform web content into a portable format while preserving the original design and layout.
IronPDF excels in providing developers with tools to edit and manipulate PDF documents. This includes adding or removing pages, modifying text, and embedding images. We can also extract report data from the reports using IronPDF.
The library supports the creation and editing of PDF forms, enabling users to interact with documents in a dynamic way. This functionality is crucial for applications requiring input from end-users, such as surveys or application forms.
With IronPDF, implementing security measures like encryption and password protection is straightforward. These features ensure that sensitive information within PDF documents remains secure from unauthorized access.
IronPDF allows developers to render PDFs for both on-screen viewing and physical printing, ensuring high-quality output in both cases. This makes it easier to prepare documents for a range of presentation or distribution needs.
IronPDF works across various .NET platforms, adhering to .NET code standards and facilitating development in diverse environments without compatibility issues.
IronPDF is backed by detailed documentation and dedicated support, helping developers navigate the library's features and integrate its functionalities into their applications efficiently.
IronPDF offers many advanced editing features. This includes the ability to merge and split PDF documents, which is particularly useful for organizing large volumes of information or extracting specific sections from a document for separate use.
The library allows for the customization of headers and footers within PDF documents. This capability is essential for adding consistent branding, page numbers, or document titles across pages, enhancing the professional appearance of the output.
Creating a console application in Visual Studio IDE is a straightforward process that involves several steps.
Begin by opening Microsoft Visual Studio. If you don't have it installed, you'll need to download and install it from the official Microsoft website. Once installed, launch the visual studio.
After opening Visual Studio, you'll be greeted with the start window. Here, select the "Create a new project" option to initiate the process of setting up a new console application.
In the "Create a new project" window, you'll be presented with a variety of project templates. Type "console" into the search box to filter the options, then select "Console App" from the list. Make sure you choose the template that corresponds to the programming language you wish to use, such as C#.
Once you've selected the console app template, click "Next" to proceed to the project configuration screen. Here, you will need to provide some details about your project:
After filling out all necessary information, click the "Create" button. Visual Studio will now generate a new console application project based on your specifications. This process may take a few moments.
To leverage IronPDF's capabilities in your project, you need to install the library first. There are several methods to accomplish this, each suited to different development workflows or preferences. Below are three common methods for installing the IronPDF library into your Visual Studio project.
The NuGet Package Manager UI in Visual Studio provides a straightforward way to browse, select, and install packages.
For those who prefer using command-line tools, the NuGet Package Manager Console is a powerful alternative.
Open the Console: Go to the "Tools" menu in Visual Studio, then navigate to "NuGet Package Manager" > "Package Manager Console".
Install-Package IronPdfThis command instructs NuGet to download and install the latest version of IronPDF into your project.
If you prefer to manually download the package or need a specific version of IronPDF, the NuGet website is a good option.
Open your web browser and go to the Report.NET GitHub repository at https://github.com/ritchiecarroll/Report.NET/tree/master. This page contains the most recent version of the Report.NET library along with its source code.
On the repository page, locate the "Code" button and click it. In the dropdown menu, select "Download ZIP" to download the entire repository as a ZIP file. Save this file to a convenient location on your computer and extract its contents.
After extracting the ZIP file, you'll find the Report.NET library source code among the extracted files. To use Report.NET in your Visual Studio project, follow these steps:
IronPDF comes with a suite of advanced features designed to handle a wide range of PDF-related tasks with ease.
IronPDF can take HTML content, including CSS and JavaScript, and render it directly into a PDF document. This means web pages or HTML templates can be converted into PDFs that look just like they do in a browser.
IronPDF allows for direct conversion of HTML strings to PDF. This means that developers can take HTML code stored as a string variable and use IronPDF to render it into a PDF file. This feature is particularly useful when the HTML content is dynamically generated or modified by the application before conversion.
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");Similarly, IronPDF can convert existing HTML files into PDF documents. This is done by reading the HTML file from the file system and using IronPDF to create a PDF document with the same formatting and structure.
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 is also capable of rendering a PDF from a live URL. This allows developers to input a web address, and IronPDF will fetch the HTML content from the URL and render it as a 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");
With IronPDF, you can edit existing PDF documents. This includes adding text, images, and pages or removing pages from the document. You can also find and replace text from the PDF document.
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");
This library can extract text and images from PDF files, similar to Crystal Reports, which you can use for indexing, searching, or repurposing content.
IronPDF supports the creation of PDF forms. Developers can programmatically create forms within a PDF and users can fill them out.
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");
You can combine multiple PDF files into a single document. This feature is handy for consolidating reports or combining different document sections.
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");
Conversely, IronPDF can split a single PDF into multiple documents. This might be needed if you want to distribute individual pages or sections.
IronPDF allows for the encryption and decryption of PDF documents, adding an extra layer of security to sensitive information.
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");With this library, setting document properties like the title, author, and metadata is straightforward. This helps with document management and organization.
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 can generate PDF/A compliant documents, which are required for long-term archiving and record-keeping purposes.
Direct conversion of XML to PDF is not supported by IronPDF but a viable approach involves initially converting XML data to HTML format. This is accomplished by employing XSLT (Extensible Stylesheet Language Transformations), a powerful XML stylesheet language designed for transforming XML documents into other formats like HTML, text, or even a new XML document. Let say that it is our data.xml file:
<?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>And it is our style.xslt file:
<?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>Here's the snippet code that how we can approach this logic:
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");It is how we generate reports using XML and IronPDF. The output PDF file which we generate:
We can also create SAP interactive reports programmatically and then convert them using IronPDF. For more detail guide, follow this guide about C# Report generation.
Report.NET provides a suite of advanced features that allow for comprehensive PDF generation and customization. The features listed in the image reflect some of these advanced capabilities. Let’s explore each one in detail.
This feature enables the use of various font styles and sizes within a PDF document. It allows developers to test the appearance of different fonts, ensuring that the text is displayed correctly and according to the design specifications.
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;
}
}
}
With the Image Sample feature, developers can embed images into PDF documents. This includes controlling the size and positioning of the images, as well as potentially applying transformations or effects to them.
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"));
}
}
}
The List Layout Manager provides a way to add lists to a PDF document. This is useful for creating ordered or unordered lists, customizing list indentation, bullet styles, and managing the overall layout of list items within the document.
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"));
}
}
}
This refers to the ability to set and modify various properties of the PDF document itself, such as metadata (author, title, subject), viewing preferences, and security settings like encryption and access permissions.
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"));
}
}
}The PDF From Text feature showcases the library’s capabilities in adding and customizing text content in a PDF. This includes setting text alignment, line spacing, color, and applying text effects like bold or italic.
IronPDF is known for its extensive and detailed documentation. IronPDF offers a well-organized documentation section that includes setup instructions, tutorials, and API references. The guides are structured to help both beginners and experienced developers find the information they need quickly. For community-driven support, developers can turn to forums and community discussions. Here, they can ask questions, share experiences, and find answers from other users.
IronPDF also offers professional support through a ticketing system where engineers can get help directly from the IronPDF team. This service might be part of the paid licensing, which offers more direct and immediate assistance.
Report.NET, being an open-source library, has a different approach to documentation and support. The documentation might not be as extensive as commercial libraries, but it is sufficient to get started and to handle common tasks. The library’s documentation is found within the GitHub repository or as inline comments in the source code. It tends to be more technical and may require some digging to find the needed information.
As Report.NET is a free and open-source library, it does not offer formal professional support. Developers rely on the community for help or might need to hire a specialist for more in-depth issues.
IronPDF offers a variety of licensing models to suit different development and deployment needs, ensuring that there's a fit for projects and organizations of all sizes. Here's an overview:
In addition to the core licenses, there are options for extended coverage:
Report.NET is distributed for free under the LGPL license. The LGPL (Lesser General Public License) is a free software license that allows users to run, study, share, and modify the software. The license ensures that the Report.NET library is free to use in both open-source and proprietary software, as long as the LGPL-licensed portions of the code are not modified. If they are modified, those modifications must be shared under the same license.
When looking at IronPDF and Report.NET, we've examined various elements such as their capabilities, the range of features they offer, ease of use, support services, and how they are licensed.
IronPDF provides a rich set of features that allow developers not only to create and edit PDF files from HTML, images, and text but also to implement advanced features such as encryption, digital signatures, and tailored headers/footers. The support for different licensing means it can suit different sizes of projects from solo developers to large enterprises. Its comprehensive documentation and professional support structure make it suitable for projects where consistent updates and direct assistance are important. IronPDF also offers a free trial of IronPDF starts from $749.
Report.NET, in contrast, is a straightforward tool adept at generating PDF documents. Its LGPL license means it is quite accessible for developers to use in both personal and commercial projects without significant restrictions. Although it might not offer the same level of structured support as IronPDF, the open-source nature of Report.NET encourages community input and help.
Your decision between IronPDF and Report.NET will hinge on the specific demands of your project. If your project requires detailed PDF creation and manipulation with the backing of professional support, IronPDF could be the go-to choice.
Install-Package IronPdf
No credit card required
Your trial key should be in the email.
If it is not, please contact
support@ironsoftware.com
No credit card required
Get started for FREE
No credit card required
Test in production without watermarks.
Works wherever you need it to.
Get 30 days of fully functional product.
Have it up and running in minutes.
Full access to our support engineering team during your product trial
No credit card or account creation required
Your trial key should be in the email.
If it is not, please contact
support@ironsoftware.com
Get started for FREE
No credit card required
Test in production without watermarks.
Works wherever you need it to.
Get 30 days of fully functional product.
Have it up and running in minutes.
Full access to our support engineering team during your product trial
Licenses from $749. Have a question? Get in touch.
Book a 30-minute, personal demo.
No contract, no card details, no commitments.
10 .NET API products for your office documents
