PDFSharp HTML to PDF Example and Tutorials Comparison

Overview of Features

IronPDF: A Comprehensive PDF Solution

IronPDF is a feature-packed .NET library that excels in many areas, including HTML-to-PDF conversion, PDF editing, and secure document processing. It can be easily added to your projects using the NuGet Package Manager Console and integrates seamlessly into your C# projects.

Its standout capabilities include:

• HTML to PDF Conversion: Convert complex web pages, including JavaScript, CSS, and AJAX, into fully rendered PDF files.
• PDF Editing: Manipulate PDF documents by adding text, images, annotations, and even redacting sensitive information.
• PDF Security: Full support for digital signatures, password protection, and encryption with up to 256-bit security.
• Form Filling & Extraction: Populate, extract, and manipulate PDF forms dynamically.

PDFsharp: A Lightweight Alternative

PDFsharp is a free, open-source library primarily designed for basic PDF creation and manipulation. While it doesn’t offer the rich feature set that IronPDF does, it's an excellent choice for simpler projects that don’t require complex functionality. Some of the core features of PDFsharp include:

• PDF Creation: Generate PDFs programmatically using C# or VB.NET, creating text-based documents with images and graphics.
• PDF Modification: Simple tasks such as merging, splitting, and editing existing PDFs.
• Basic Encryption: Add basic password protection to PDF documents.

🚨 Key Limitation: PDFsharp does not support HTML-to-PDF conversion natively, requiring third-party tools like Polybioz.HtmlRenderer.PdfSharp.Core, adding complexity.

Compatibility and Usability

Cross-Platform Support

IronPDF

IronPDF is designed to be cross-platform, fully compatible with .NET Core, .NET Framework, and Azure, and supports Windows, macOS, and Linux. This makes it an ideal choice for projects that need to run across multiple operating systems and ensures the library has universal compatibility with most development environments. The library integrates seamlessly with modern web development environments, making it perfect for web applications, cloud solutions, and enterprise systems.

PDFsharp

PDFsharp is primarily designed for the .NET Framework and offers limited support for .NET Core. While there is a .NET Core version, it’s still a work in progress, and certain features are not fully optimized for non-Windows platforms. Linux and macOS users may face compatibility issues, making PDFsharp a less ideal choice for cross-platform applications.

Ease of Use

IronPDF offers a developer-friendly API that abstracts away the complexity of working with PDF files. Whether you’re generating PDFs or editing existing files, the syntax is clean and intuitive, allowing developers to implement complex functionality in just a few lines of code.

PDFsharp, while relatively easy to use for basic tasks like text generation and PDF manipulation, often requires more manual handling for tasks such as complex document generation and editing.

Ease of Use Example

IronPDF: Converting HTML to PDF

Easily convert HTML snippets and content to PDF with a single method call:

using IronPdf;

var renderer = new ChromePdfRenderer();
var content = "<h1>IronPDF Rocks!</h1>";
var pdf = renderer.RenderHtmlAsPdf(content);
pdf.SaveAs("output.pdf");

using IronPdf;

var renderer = new ChromePdfRenderer();
var content = "<h1>IronPDF Rocks!</h1>";
var pdf = renderer.RenderHtmlAsPdf(content);
pdf.SaveAs("output.pdf");

Imports IronPdf



Private renderer = New ChromePdfRenderer()

Private content = "<h1>IronPDF Rocks!</h1>"

Private pdf = renderer.RenderHtmlAsPdf(content)

pdf.SaveAs("output.pdf")

✔ Concise, clean code\ ✔ Effortless conversion from existing HTML content

PDFsharp: Creating a PDF with Text

PDFsharp requires manual implementation for drawing text and content through the use of a graphics object:

using PdfSharp.Pdf;
using PdfSharp.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
var gfx = XGraphics.FromPdfPage(page);
var font = new XFont("Arial", 20, XFontStyleEx.Bold);
gfx.DrawString("Hello, PDFsharp!", font, XBrushes.Black, new XPoint(50, 100));
document.Save("output.pdf");

using PdfSharp.Pdf;
using PdfSharp.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
var gfx = XGraphics.FromPdfPage(page);
var font = new XFont("Arial", 20, XFontStyleEx.Bold);
gfx.DrawString("Hello, PDFsharp!", font, XBrushes.Black, new XPoint(50, 100));
document.Save("output.pdf");

Imports PdfSharp.Pdf

Imports PdfSharp.Drawing



Private document = New PdfDocument()

Private page = document.AddPage()

Private gfx = XGraphics.FromPdfPage(page)

Private font = New XFont("Arial", 20, XFontStyleEx.Bold)

gfx.DrawString("Hello, PDFsharp!", font, XBrushes.Black, New XPoint(50, 100))

document.Save("output.pdf")

🚨 Limitations:\ ❌ Manual implementation – You must manually position elements.\ ❌ More complex for generating reports, invoices, or styled content.

Feature Comparison

HTML to PDF Conversion

IronPDF: Best for Web Applications & Dynamic Reports

IronPDF excels in converting HTML reports, web pages, and dynamic content into PDFs while preserving CSS, JavaScript, and embedded images. This makes it ideal for:

• Invoice generation from HTML templates.
• Automated report creation from web applications.
• Capturing web pages as PDFs for offline use.

IronPDF Code Example – Converting HTML File to PDF Format:

using IronPdf;

ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlFileAsPdf("example.html");
pdf.SaveAs("example.pdf");

using IronPdf;

ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlFileAsPdf("example.html");
pdf.SaveAs("example.pdf");

Imports IronPdf



Private renderer As New ChromePdfRenderer()

Private pdf As PdfDocument = renderer.RenderHtmlFileAsPdf("example.html")

pdf.SaveAs("example.pdf")

Output

As you can see, with IronPDF we were able to convert a styled HTML file into a PDF document in just three simple lines of code, without losing any of the original quality or layout! If you want to see how IronPDF can handle more CSS-heavy content, why don't we look at an example where we convert the content of this URL into a PDF?

using IronPdf;

ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.JavaScript(5000);
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
PdfDocument pdf = renderer.RenderUrlAsPdf("https://www.apple.com");
pdf.SaveAs("Apple.pdf");

using IronPdf;

ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.JavaScript(5000);
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
PdfDocument pdf = renderer.RenderUrlAsPdf("https://www.apple.com");
pdf.SaveAs("Apple.pdf");

Imports IronPdf



Private renderer As New ChromePdfRenderer()

renderer.RenderingOptions.EnableJavaScript = True

renderer.RenderingOptions.WaitFor.JavaScript(5000)

renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print

Dim pdf As PdfDocument = renderer.RenderUrlAsPdf("https://www.apple.com")

pdf.SaveAs("Apple.pdf")

Output

Here, we take advantage of IronPDF's powerful rendering options to convert the web content into a high-quality PDF that maintains all of the original CSS and JavaScript content.

PDFsharp: Best for Static PDFs Without Web Content

PDFsharp does not natively support HTML-to-PDF conversion. If you need this feature, you must use third-party libraries like Html Renderer, which provides the ability to convert HTML content into PDF documents using static rendering code. Because of these limitations, PDFsharp is usually best used for:

• Static documents that do not rely on dynamic HTML rendering.
• Invoices, contracts, and reports where content is defined programmatically.

PDFsharp with HtmlRenderer Example:

using PdfSharp.Pdf;
using TheArtOfDev.HtmlRenderer.PdfSharp;

var document = new PdfSharpCore.Pdf.PdfDocument();
string htmlContent = File.ReadAllText("index.html");
PdfGenerator.AddPdfPages(document, htmlContent, PdfSharpCore.PageSize.A4);
document.Save("html-to-pdf-pdfsharp.pdf");

using PdfSharp.Pdf;
using TheArtOfDev.HtmlRenderer.PdfSharp;

var document = new PdfSharpCore.Pdf.PdfDocument();
string htmlContent = File.ReadAllText("index.html");
PdfGenerator.AddPdfPages(document, htmlContent, PdfSharpCore.PageSize.A4);
document.Save("html-to-pdf-pdfsharp.pdf");

Imports PdfSharp.Pdf

Imports TheArtOfDev.HtmlRenderer.PdfSharp



Private document = New PdfSharpCore.Pdf.PdfDocument()

Private htmlContent As String = File.ReadAllText("index.html")

PdfGenerator.AddPdfPages(document, htmlContent, PdfSharpCore.PageSize.A4)

document.Save("html-to-pdf-pdfsharp.pdf")

Output

Thanks to the HtmlRenderer add-on, we are able to convert most HTML content to PDF while maintaining most of the original styling, but how does it stand up against IronPDF when it comes to more CSS-heavy content? Let's take a look at the process behind converting web content into PDF files:

using PdfSharpCore.Pdf;
using TheArtOfDev.HtmlRenderer.PdfSharp;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Define the URL to fetch HTML content
        string url = "https://www.example.com"; // Replace with the URL you want to convert

        // Fetch HTML content from the URL
        string htmlContent = await FetchHtmlFromUrl(url);

        // Generate the PDF from the fetched HTML content
        var document = new PdfSharpCore.Pdf.PdfDocument();
        PdfGenerator.AddPdfPages(document, htmlContent, PdfSharpCore.PageSize.A4);

        // Save the generated PDF to a file
        document.Save("url-to-pdf-example.pdf");

        System.Console.WriteLine("PDF created successfully!");
    }

    // Method to fetch HTML content from a URL
    private static async Task<string> FetchHtmlFromUrl(string url)
    {
        using (HttpClient client = new HttpClient())
        {
            // Send GET request to fetch the HTML content of the URL
            HttpResponseMessage response = await client.GetAsync(url);

            if (response.IsSuccessStatusCode)
            {
                // Read the content as a string
                string htmlContent = await response.Content.ReadAsStringAsync();
                return htmlContent;
            }
            else
            {
                throw new Exception($"Failed to fetch content from URL. Status Code: {response.StatusCode}");
            }
        }
    }
}

using PdfSharpCore.Pdf;
using TheArtOfDev.HtmlRenderer.PdfSharp;
using System.Net.Http;
using System.Threading.Tasks;
using System.IO;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Define the URL to fetch HTML content
        string url = "https://www.example.com"; // Replace with the URL you want to convert

        // Fetch HTML content from the URL
        string htmlContent = await FetchHtmlFromUrl(url);

        // Generate the PDF from the fetched HTML content
        var document = new PdfSharpCore.Pdf.PdfDocument();
        PdfGenerator.AddPdfPages(document, htmlContent, PdfSharpCore.PageSize.A4);

        // Save the generated PDF to a file
        document.Save("url-to-pdf-example.pdf");

        System.Console.WriteLine("PDF created successfully!");
    }

    // Method to fetch HTML content from a URL
    private static async Task<string> FetchHtmlFromUrl(string url)
    {
        using (HttpClient client = new HttpClient())
        {
            // Send GET request to fetch the HTML content of the URL
            HttpResponseMessage response = await client.GetAsync(url);

            if (response.IsSuccessStatusCode)
            {
                // Read the content as a string
                string htmlContent = await response.Content.ReadAsStringAsync();
                return htmlContent;
            }
            else
            {
                throw new Exception($"Failed to fetch content from URL. Status Code: {response.StatusCode}");
            }
        }
    }
}

Imports PdfSharpCore.Pdf

Imports TheArtOfDev.HtmlRenderer.PdfSharp

Imports System.Net.Http

Imports System.Threading.Tasks

Imports System.IO



Public Class Program

	Public Shared Async Function Main(ByVal args() As String) As Task

		' Define the URL to fetch HTML content

		Dim url As String = "https://www.example.com" ' Replace with the URL you want to convert



		' Fetch HTML content from the URL

		Dim htmlContent As String = Await FetchHtmlFromUrl(url)



		' Generate the PDF from the fetched HTML content

		Dim document = New PdfSharpCore.Pdf.PdfDocument()

		PdfGenerator.AddPdfPages(document, htmlContent, PdfSharpCore.PageSize.A4)



		' Save the generated PDF to a file

		document.Save("url-to-pdf-example.pdf")



		System.Console.WriteLine("PDF created successfully!")

	End Function



	' Method to fetch HTML content from a URL

	Private Shared Async Function FetchHtmlFromUrl(ByVal url As String) As Task(Of String)

		Using client As New HttpClient()

			' Send GET request to fetch the HTML content of the URL

			Dim response As HttpResponseMessage = Await client.GetAsync(url)



			If response.IsSuccessStatusCode Then

				' Read the content as a string

				Dim htmlContent As String = Await response.Content.ReadAsStringAsync()

				Return htmlContent

			Else

				Throw New Exception($"Failed to fetch content from URL. Status Code: {response.StatusCode}")

			End If

		End Using

	End Function

End Class

Output

While PDFsharp can't handle the same intensive CSS and JavaScript content as IronPDF, it is still a strong contender for those looking for a lightweight PDF library for PDF generation tasks that aren't reliant on CSS or JavaScript content. While it requires additional libraries for HTML conversion, PDFsharp is capable of creating PDF files from scratch within the .NET ecosystem.

Encryption and Security

IronPDF: Best for Secure, Compliance-Driven Applications

IronPDF is a top choice for developers needing secure PDF handling, especially in applications that require compliance with stringent data protection regulations. It offers advanced security features designed to ensure that your PDF documents remain secure and tamper-proof, making it suitable for industries such as finance, healthcare, and law.

Use Cases for IronPDF:

• Legal and Financial Documents: IronPDF allows you to protect sensitive data in PDFs with advanced encryption methods, ensuring that only authorized users can access them.
• Documents Requiring Digital Signatures: It offers digital signature functionality that ensures the authenticity of a document, which is critical in legal agreements and contracts.
• GDPR and HIPAA Compliance: When dealing with personal or sensitive information, IronPDF supports encryption standards that meet regulations such as GDPR and HIPAA, providing peace of mind for developers handling secure client data.

IronPDF’s encryption capabilities include both user-level and owner-level passwords, meaning that you can restrict access to PDFs or limit specific actions such as printing, copying, or editing. Additionally, it allows you to apply digital signatures to PDFs, ensuring both data integrity and non-repudiation, making it ideal for legal documents. These features are especially useful in workflows where document security is paramount.

IronPDF Code Example – Encrypt a PDF with a Password:

using IronPdf;

var pdf = PdfDocument.FromFile("ConfidentialDocument.pdf");
pdf.SecuritySettings.UserPassword = "user";
pdf.SecuritySettings.OwnerPassword = "owner";
pdf.SecuritySettings.AllowUserEdits = IronPdf.Security.PdfEditSecurity.NoEdit;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SaveAs("ConfidentialDocumentSecured.pdf");

using IronPdf;

var pdf = PdfDocument.FromFile("ConfidentialDocument.pdf");
pdf.SecuritySettings.UserPassword = "user";
pdf.SecuritySettings.OwnerPassword = "owner";
pdf.SecuritySettings.AllowUserEdits = IronPdf.Security.PdfEditSecurity.NoEdit;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SaveAs("ConfidentialDocumentSecured.pdf");

Imports IronPdf



Private pdf = PdfDocument.FromFile("ConfidentialDocument.pdf")

pdf.SecuritySettings.UserPassword = "user"

pdf.SecuritySettings.OwnerPassword = "owner"

pdf.SecuritySettings.AllowUserEdits = IronPdf.Security.PdfEditSecurity.NoEdit

pdf.SecuritySettings.AllowUserAnnotations = False

pdf.SaveAs("ConfidentialDocumentSecured.pdf")

Output

In this example, IronPDF encrypts the PDF and restricts user actions, ensuring that the document is protected from unauthorized access or manipulation.

PDFsharp: Best for Basic Security Needs

While PDFsharp offers basic password protection, it lacks advanced features like digital signatures, watermarking, or sophisticated encryption. For simple use cases where you only need to restrict access to a PDF or apply a basic password, PDFsharp is a good fit. However, if your application requires more advanced security features, such as secure document signing or encryption to meet compliance standards, you might find PDFsharp lacking.

Use Cases for PDFsharp:

• Protecting Internal Documents: PDFsharp is suitable for protecting PDFs with basic password protection to prevent unauthorized access to internal reports, invoices, and contracts.
• Basic Encryption for Confidential Files: If your application doesn't require compliance-driven security but you still want to ensure that unauthorized users can't open sensitive PDFs, PDFsharp’s password protection is a simple solution.

However, PDFsharp’s encryption capabilities are limited compared to IronPDF, making it unsuitable for scenarios where strong security is a requirement. It can protect PDFs with a user password and restrict certain actions like printing and copying, but it doesn’t offer the robust encryption standards needed for industries like finance or healthcare.

PDFsharp Code Example – Basic PDF Encryption:

using PdfSharp.Pdf;
using PdfSharp.Pdf.Security;
using PdfSharp.Drawing;

// Create a new document
var document = new PdfSharp.Pdf.PdfDocument();

// Add a page and draw something on it
var page = document.AddPage();
var gfx = XGraphics.FromPdfPage(page);
var font = new XFont("Arial", 16, XFontStyleEx.Bold);
gfx.DrawString("Confidential Document", font, XBrushes.Black, new XPoint(50, 50));

// Set password protection
document.SecuritySettings.UserPassword = "password123";
document.SecuritySettings.OwnerPassword = "admin456";

// Save the encrypted PDF
document.Save("pdfsharp-encrypted.pdf");

using PdfSharp.Pdf;
using PdfSharp.Pdf.Security;
using PdfSharp.Drawing;

// Create a new document
var document = new PdfSharp.Pdf.PdfDocument();

// Add a page and draw something on it
var page = document.AddPage();
var gfx = XGraphics.FromPdfPage(page);
var font = new XFont("Arial", 16, XFontStyleEx.Bold);
gfx.DrawString("Confidential Document", font, XBrushes.Black, new XPoint(50, 50));

// Set password protection
document.SecuritySettings.UserPassword = "password123";
document.SecuritySettings.OwnerPassword = "admin456";

// Save the encrypted PDF
document.Save("pdfsharp-encrypted.pdf");

Imports PdfSharp.Pdf

Imports PdfSharp.Pdf.Security

Imports PdfSharp.Drawing



' Create a new document

Private document = New PdfSharp.Pdf.PdfDocument()



' Add a page and draw something on it

Private page = document.AddPage()

Private gfx = XGraphics.FromPdfPage(page)

Private font = New XFont("Arial", 16, XFontStyleEx.Bold)

gfx.DrawString("Confidential Document", font, XBrushes.Black, New XPoint(50, 50))



' Set password protection

document.SecuritySettings.UserPassword = "password123"

document.SecuritySettings.OwnerPassword = "admin456"



' Save the encrypted PDF

document.Save("pdfsharp-encrypted.pdf")

Output

In this code, PDFsharp simply applies a user password to the PDF document to restrict access.

Functional Applications

IronPDF: Best for Comprehensive PDF Editing, Redaction, and Conversion

IronPDF shines in scenarios that require comprehensive PDF editing, redaction, and the ability to handle multiple file formats like DOCX to PDF conversion. It’s ideal for developers working on applications that need advanced PDF manipulation with the ability to easily integrate into business workflows.

Real-world Use Cases for IronPDF:

• Redacting Sensitive Information: IronPDF is highly effective for use in industries like legal, healthcare, and government, where sensitive information (such as personal data, financial details, or medical records) needs to be removed or hidden in PDF documents. Redaction involves not just covering text, but ensuring that the redacted information cannot be recovered.
• Automating PDF Creation from DOCX Files: IronPDF makes it simple to convert Microsoft Word documents (DOCX) to PDFs. This is especially useful in environments like enterprise software or e-commerce, where invoices, reports, or contracts are often generated from Word documents and need to be converted to secure PDFs for archiving or distribution.
• Editable PDF Forms: If you're building interactive PDF forms that allow users to enter data (e.g., applications, surveys, feedback forms), IronPDF allows you to create and modify fillable forms. This feature is commonly used in industries like HR, education, and customer support.

Example Use Case – Converting DOCX to PDF and Adding a Watermark: In a corporate setting, IronPDF can be used to convert Word documents to PDFs and then add a watermark for branding or security purposes. With IronPDF, you can apply the watermark to a specified page or across all of the PDF pages.

Here, we will take a sample DOCX file and apply a watermark to label it as a draft, with example company branding.

using IronPdf;
using IronPdf.Editing;

DocxToPdfRenderer renderer = new DocxToPdfRenderer();
PdfDocument pdf = renderer.RenderDocxAsPdf("document.docx");
var watermark = "<h1 style='Color: red; font-size: 60px'>DRAFT</h1><img style='width: 200px' src='https://ironsoftware.com/img/products/ironpdf-logo-text-dotnet.svg'>";
pdf.ApplyWatermark(watermark, opacity: 75, VerticalAlignment.Top, HorizontalAlignment.Right);
pdf.SaveAs("output.pdf");

using IronPdf;
using IronPdf.Editing;

DocxToPdfRenderer renderer = new DocxToPdfRenderer();
PdfDocument pdf = renderer.RenderDocxAsPdf("document.docx");
var watermark = "<h1 style='Color: red; font-size: 60px'>DRAFT</h1><img style='width: 200px' src='https://ironsoftware.com/img/products/ironpdf-logo-text-dotnet.svg'>";
pdf.ApplyWatermark(watermark, opacity: 75, VerticalAlignment.Top, HorizontalAlignment.Right);
pdf.SaveAs("output.pdf");

Imports IronPdf

Imports IronPdf.Editing



Private renderer As New DocxToPdfRenderer()

Private pdf As PdfDocument = renderer.RenderDocxAsPdf("document.docx")

Private watermark = "<h1 style='Color: red; font-size: 60px'>DRAFT</h1><img style='width: 200px' src='https://ironsoftware.com/img/products/ironpdf-logo-text-dotnet.svg'>"

pdf.ApplyWatermark(watermark, opacity:= 75, VerticalAlignment.Top, HorizontalAlignment.Right)

pdf.SaveAs("output.pdf")

Output

In this example, IronPDF first converts a DOCX document into a PDF and then adds a watermark to ensure the document is labeled as a "DRAFT". This functionality is useful for companies that need to distribute sensitive information while ensuring that the document's security is maintained or to keep track of which documents are drafts.

PDFsharp: Great for Lightweight PDF Editing and Simple Document Generation

PDFsharp is more suited to basic PDF operations, where lightweight editing and document creation from scratch are needed. It excels at tasks such as creating simple PDFs from scratch, modifying existing PDFs, and applying basic redaction. However, when it comes to more complex operations, such as advanced redaction, document conversion, or working with form data, PDFsharp's capabilities are more limited compared to IronPDF.

Real-world Use Cases for PDFsharp:

• Generating Simple Reports and Documents: PDFsharp is excellent for creating simple, static documents, such as reports, invoices, or brochures. It's often used in small business applications where PDF generation doesn’t need to be overly complex but needs to include basic formatting like text, images, and tables.
• Basic PDF Editing and Merging: In scenarios where you need to combine multiple PDFs into a single document or split large PDFs into smaller sections, PDFsharp provides simple functionality for handling these tasks. It's a good fit for document management systems that need lightweight operations without the need for advanced PDF manipulation.
• Basic Redaction: While PDFsharp does not offer advanced redaction features like IronPDF, it can be used for basic redaction, such as covering up text or images with shapes or solid colors. This can be enough for low-security documents or in applications that don’t require compliance with strict data privacy laws.

Example Use Case: In a business environment, PDFsharp could be used to generate reports from data extracted from a database, merge multiple files into one, or redact a portion of the document for internal use.

PDFsharp Code Example – Merging Two PDFs:

using PdfSharp.Pdf;
using PdfSharp.Pdf.IO;

// Open the first PDF
PdfDocument document1 = PdfReader.Open("document1.pdf", PdfDocumentOpenMode.Import);

// Open the second PDF
PdfDocument document2 = PdfReader.Open("document2.pdf", PdfDocumentOpenMode.Import);

// Create a new PDF document for the merged file
PdfDocument outputDocument = new PdfDocument();

// Add pages from the first document
foreach (PdfPage page in document1.Pages)
{
    outputDocument.AddPage(page);
}

// Add pages from the second document
foreach (PdfPage page in document2.Pages)
{
    outputDocument.AddPage(page);
}

// Save the merged PDF
outputDocument.Save("merged-document.pdf");

using PdfSharp.Pdf;
using PdfSharp.Pdf.IO;

// Open the first PDF
PdfDocument document1 = PdfReader.Open("document1.pdf", PdfDocumentOpenMode.Import);

// Open the second PDF
PdfDocument document2 = PdfReader.Open("document2.pdf", PdfDocumentOpenMode.Import);

// Create a new PDF document for the merged file
PdfDocument outputDocument = new PdfDocument();

// Add pages from the first document
foreach (PdfPage page in document1.Pages)
{
    outputDocument.AddPage(page);
}

// Add pages from the second document
foreach (PdfPage page in document2.Pages)
{
    outputDocument.AddPage(page);
}

// Save the merged PDF
outputDocument.Save("merged-document.pdf");

Imports PdfSharp.Pdf

Imports PdfSharp.Pdf.IO



' Open the first PDF

Private document1 As PdfDocument = PdfReader.Open("document1.pdf", PdfDocumentOpenMode.Import)



' Open the second PDF

Private document2 As PdfDocument = PdfReader.Open("document2.pdf", PdfDocumentOpenMode.Import)



' Create a new PDF document for the merged file

Private outputDocument As New PdfDocument()



' Add pages from the first document

For Each page As PdfPage In document1.Pages

	outputDocument.AddPage(page)

Next page



' Add pages from the second document

For Each page As PdfPage In document2.Pages

	outputDocument.AddPage(page)

Next page



' Save the merged PDF

outputDocument.Save("merged-document.pdf")

Output

This code demonstrates how PDFsharp can be used to merge two PDF documents into one. This is a common use case for applications that need to combine multiple reports, invoices, or other documents into a single PDF.

Pricing and Licensing

IronPDF and PDFsharp offer different approaches to pricing and licensing, catering to various needs. IronPDF provides a perpetual licensing model, while PDFsharp is open-source and free to use.

IronPDF Pricing and Licensing:

IronPDF uses a perpetual licensing model, meaning users get lifetime access with annual updates. It offers tiered pricing based on usage, including individual, team, or enterprise licenses. A free trial is available, allowing users to test the tool before purchasing. Commercial license users also get technical support and feature updates.

• Perpetual Licensing: Lifetime access, including annual updates.
• Tiered Licenses: Licenses for individuals, teams, or enterprises.
• Free Trial: Users can try before buying.
• Commercial Support: Access to support and regular updates.

PDFsharp Licensing:

PDFsharp is free under the MIT License, meaning it's open-source and free for both personal and commercial use. However, it doesn’t offer premium support, leaving users to rely on community forums for assistance. This suits smaller or open-source projects but may require external help for more complex needs.

• MIT License: Free for commercial use.
• No Premium Support: Community forums for assistance.
• Flexibility: Ideal for smaller projects.

End User Support and Documentation

IronPDF excels in developer support, offering detailed documentation and multiple channels for assistance. Unlike PDFsharp, IronPDF provides structured resources that help developers throughout the integration process.

IronPDF Developer Support:

IronPDF provides comprehensive documentation, including step-by-step guides, API references, and code samples. A dedicated support team is available for technical queries. Additionally, an online knowledge base offers troubleshooting solutions and helpful tips. For enterprise customers, priority support ensures faster issue resolution.

• Comprehensive Documentation: Detailed guides and code examples.
• Support Team: Direct access to technical support.
• Knowledge Base: FAQs and troubleshooting tips.
• Priority Support: Fast issue resolution for businesses.

Engaging Community Aspect:

IronPDF also fosters an active developer community. Users can engage in the community forum, where they can ask questions, share experiences, and find solutions. In addition, tutorials and video guides help users get started quickly. IronPDF is also present on GitHub, allowing the community to report bugs and suggest features.

• Community Forum: A space to ask questions and share solutions.
• Tutorials & Guides: Step-by-step instructions and video resources.
• GitHub Collaboration: Users can contribute and suggest new features.

PDFsharp Developer Support:

PDFsharp’s support primarily comes from its GitHub repository and community forums like Stack Overflow. Developers can report issues, browse solutions, or ask questions. However, the documentation is limited, and detailed guides or official tutorials are scarce, requiring developers to rely on community contributions or trial and error.

• GitHub Repository: Report issues and explore solutions.
• Community Forums: Find help on Stack Overflow.
• Sparse Documentation: Limited guides and resources.

Community-Driven Contributions:

The lack of official support means developers can contribute to PDFsharp via GitHub, improving documentation or adding features. Although there are user-contributed tutorials, the absence of a dedicated support team means troubleshooting can take longer.

• Open-Source Contributions: Users can improve documentation.
• Collaborative Troubleshooting: Rely on the community for help.

Licensing, Documentation, and Support Summary

Conclusion

When choosing between IronPDF and PDFsharp, the decision largely depends on your project's requirements. IronPDF is a powerful, feature-rich solution with advanced capabilities like converting HTML-to-PDF, robust encryption, and strong cross-platform support. It's ideal for businesses, enterprises, and developers needing high-quality PDF manipulation, security features, and dedicated support.

On the other hand, PDFsharp is a solid, open-source choice for simpler projects that don't require advanced features, offering ease of use and flexibility with basic PDF creation and editing.

If you're looking for an all-in-one PDF solution with extensive functionality, we encourage you to explore IronPDF. With its commercial support and continual updates, IronPDF is built to scale with your development needs and ensures that your PDFs are handled efficiently and securely. Try IronPDF today and discover how it can streamline your PDF workflows!