HTML to PDF in C# .NET

// Import the necessary namespace from the IronPdf library
using IronPdf;

// Create a new instance of the ChromePdfRenderer class.
// This class is used to render HTML content to a PDF file.
var renderer = new ChromePdfRenderer();

// Use the renderer to convert a simple HTML string into a PDF document.
// The RenderHtmlAsPdf method takes an HTML string as an argument and renders it as a PDF.
var pdfDocument = renderer.RenderHtmlAsPdf("<h1> Hello IronPdf </h1>");

// Save the rendered PDF document to a file named "pixel-perfect.pdf".
// The SaveAs method takes a file path as an argument where the PDF will be saved.
pdfDocument.SaveAs("pixel-perfect.pdf");

' Import the necessary namespace from the IronPdf library

Imports IronPdf



' Create a new instance of the ChromePdfRenderer class.

' This class is used to render HTML content to a PDF file.

Private renderer = New ChromePdfRenderer()



' Use the renderer to convert a simple HTML string into a PDF document.

' The RenderHtmlAsPdf method takes an HTML string as an argument and renders it as a PDF.

Private pdfDocument = renderer.RenderHtmlAsPdf("<h1> Hello IronPdf </h1>")



' Save the rendered PDF document to a file named "pixel-perfect.pdf".

' The SaveAs method takes a file path as an argument where the PDF will be saved.

pdfDocument.SaveAs("pixel-perfect.pdf")

using IronPdf;

// Create an instance of HtmlToPdf renderer
var renderer = new HtmlToPdf();

// Render a PDF from an HTML string that includes an image tag
// - The `RenderHtmlAsPdf` method takes:
//   1. The HTML content to be rendered.
//   2. The base path for local resources like images.
// - In this example, the HTML contains an image tag with a relative path.
//   The renderer uses the base path to locate the image file.
var pdf = renderer.RenderHtmlAsPdf("<img src='image1.png'/>", @"C:\MyProject\Assets\");

// Save the generated PDF to a file
// - The file will be saved in the specified directory with the given name.
// - Ensure the directory exists and the application has the necessary permissions
//   to write files to the location.
pdf.SaveAs(@"C:\MyProject\Assets\output.pdf");

// Notes:
// 1. Ensure the IronPdf library is properly referenced in your project.
//    You can typically do this via NuGet Package Manager by installing IronPdf.
// 2. The image path specified within the HTML must be relative to the base path provided.
//    The base path is meant to direct the renderer to the correct location of images and other resources.
// 3. The resultant PDF is saved to "C:\MyProject\Assets\output.pdf".
//    Verify that the given path is correct and accessible.

Imports IronPdf



' Create an instance of HtmlToPdf renderer

Private renderer = New HtmlToPdf()



' Render a PDF from an HTML string that includes an image tag

' - The `RenderHtmlAsPdf` method takes:

'   1. The HTML content to be rendered.

'   2. The base path for local resources like images.

' - In this example, the HTML contains an image tag with a relative path.

'   The renderer uses the base path to locate the image file.

Private pdf = renderer.RenderHtmlAsPdf("<img src='image1.png'/>", "C:\MyProject\Assets\")



' Save the generated PDF to a file

' - The file will be saved in the specified directory with the given name.

' - Ensure the directory exists and the application has the necessary permissions

'   to write files to the location.

pdf.SaveAs("C:\MyProject\Assets\output.pdf")



' Notes:

' 1. Ensure the IronPdf library is properly referenced in your project.

'    You can typically do this via NuGet Package Manager by installing IronPdf.

' 2. The image path specified within the HTML must be relative to the base path provided.

'    The base path is meant to direct the renderer to the correct location of images and other resources.

' 3. The resultant PDF is saved to "C:\MyProject\Assets\output.pdf".

'    Verify that the given path is correct and accessible.

using IronPdf; // Import the IronPdf library to work with PDF creation and manipulation

// Create an instance of ChromePdfRenderer to convert web pages into PDF format
var renderer = new ChromePdfRenderer();

// RenderUrlAsPdf method creates a PDF from the content of the specified URL.
// In this case, it converts the Wikipedia page about PDFs into a PDF document.
var pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/PDF");

// Save the created PDF to the local filesystem with a specific filename.
pdf.SaveAs("wikipedia.pdf");

// Note: 
// - Ensure that the IronPdf NuGet package is installed in your project to use the IronPdf namespace.
// - The output PDF will be saved in the same directory where the executable runs.

Imports IronPdf ' Import the IronPdf library to work with PDF creation and manipulation



' Create an instance of ChromePdfRenderer to convert web pages into PDF format

Private renderer = New ChromePdfRenderer()



' RenderUrlAsPdf method creates a PDF from the content of the specified URL.

' In this case, it converts the Wikipedia page about PDFs into a PDF document.

Private pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/PDF")



' Save the created PDF to the local filesystem with a specific filename.

pdf.SaveAs("wikipedia.pdf")



' Note: 

' - Ensure that the IronPdf NuGet package is installed in your project to use the IronPdf namespace.

' - The output PDF will be saved in the same directory where the executable runs.

// Import necessary namespaces for using IronPdf functionalities
using IronPdf.Rendering;

// Initialize a new instance of the HtmlToPdf class to create a PDF document
var renderer = new HtmlToPdf();

// Set the CSS media type option for rendering
// CssMediaType.Screen is suitable for screen display formatting
// CssMediaType.Print is suitable for print formatting
// Only one of these options should be uncommented at a time

// Uncomment one of the following lines depending on your desired media type

// renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen;
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Note:
// The code sets a CSS media type to influence how the HTML content is formatted and displayed in the resulting PDF.
// PdfCssMediaType.Screen and PdfCssMediaType.Print are enum values provided by IronPdf to choose different rendering styles.
// Ensure that 'renderer' is a properly instantiated HtmlToPdf object, as shown above.

' Import necessary namespaces for using IronPdf functionalities

Imports IronPdf.Rendering



' Initialize a new instance of the HtmlToPdf class to create a PDF document

Private renderer = New HtmlToPdf()



' Set the CSS media type option for rendering

' CssMediaType.Screen is suitable for screen display formatting

' CssMediaType.Print is suitable for print formatting

' Only one of these options should be uncommented at a time



' Uncomment one of the following lines depending on your desired media type



' renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen;

renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print



' Note:

' The code sets a CSS media type to influence how the HTML content is formatted and displayed in the resulting PDF.

' PdfCssMediaType.Screen and PdfCssMediaType.Print are enum values provided by IronPdf to choose different rendering styles.

' Ensure that 'renderer' is a properly instantiated HtmlToPdf object, as shown above.

// This code snippet appears to belong to a broader context dealing with rendering or web requests.
// Based on the clues, we can assume that 'renderer' is an object dealing with rendering operations,
// possibly in a web browser automation or document rendering service, like a headless browser tool.

using System;

namespace RenderingExample
{
    // The 'renderer' object is presumed to represent some rendering system with configurable options.
    // Here, we show a plausible configuration of rendering options using imagined classes and methods.
    
    // Assuming necessary using directives based on typical rendering tools (like puppeteer-sharp for C#)

    // Enable JavaScript execution for the rendering operation (if supported by the rendering library).
    // This usually allows the rendering process to execute scripts, load dynamic content, etc.
    renderer.RenderingOptions.EnableJavaScript = true;

    // Set a delay for the rendering operation to ensure that JavaScript operations (like AJAX requests)
    // or content rendering is fully completed before taking a snapshot of the page or processing it.
    renderer.RenderingOptions.WaitFor = new WaitForOptions
    {
        // Assume RenderDelay is a property that defines a wait time in milliseconds before rendering.
        RenderDelay = 500 // Setting a rendering delay of 500 milliseconds.
    };

    // Defining WaitForOptions class to illustrate the use of a render delay setting.
    // This class should typically reside in its own file or the proper namespace.

    public class WaitForOptions
    {
        // Property to specify the render delay in milliseconds.
        public int RenderDelay { get; set; }
    }
}

// Note: The exact implementation may vary depending on the library being used for rendering.
// This setup provides a high-level overview and hypothetical implementation for illustration purposes.

' This code snippet appears to belong to a broader context dealing with rendering or web requests.

' Based on the clues, we can assume that 'renderer' is an object dealing with rendering operations,

' possibly in a web browser automation or document rendering service, like a headless browser tool.



Imports System



Namespace RenderingExample

	' The 'renderer' object is presumed to represent some rendering system with configurable options.

	' Here, we show a plausible configuration of rendering options using imagined classes and methods.



	' Assuming necessary using directives based on typical rendering tools (like puppeteer-sharp for C#)



	' Enable JavaScript execution for the rendering operation (if supported by the rendering library).

	' This usually allows the rendering process to execute scripts, load dynamic content, etc.

	renderer.RenderingOptions.EnableJavaScript = True



	' Set a delay for the rendering operation to ensure that JavaScript operations (like AJAX requests)

	' or content rendering is fully completed before taking a snapshot of the page or processing it.

	renderer.RenderingOptions.WaitFor = New WaitForOptions With {.RenderDelay = 500}



	' Defining WaitForOptions class to illustrate the use of a render delay setting.

	' This class should typically reside in its own file or the proper namespace.



'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:

'	public class WaitForOptions

'	{

'		' Property to specify the render delay in milliseconds.

'		public int RenderDelay

'		{

'			get;

'			set;

'		}

'	}

End Namespace



' Note: The exact implementation may vary depending on the library being used for rendering.

' This setup provides a high-level overview and hypothetical implementation for illustration purposes.

using IronPdf;

// This script uses the IronPdf library to render a webpage as a PDF document.

// Create an instance of ChromePdfRenderer, which uses a headless version of Chrome
// to accurately render HTML content into a PDF format.
var renderer = new ChromePdfRenderer();

// Call the RenderUrlAsPdf method on the renderer object with a specific URL.
// The URL leads to a D3.js data visualization, which will be fetched and rendered as a PDF.
var pdf = renderer.RenderUrlAsPdf("https://bl.ocks.org/mbostock/4062006");

// After the PDF is rendered, save it to the local filesystem.
// The PDF document will be saved with the name "chart.pdf" in the current working directory.
pdf.SaveAs("chart.pdf");

// Note: 
// - Ensure that the IronPdf NuGet package is installed and referenced in your project to access these functionalities.
// - The URL must be accessible publicly. Ensure network connectivity for the URL to fetch the content successfully.
// - Handle any exceptions that may arise during the execution for a production-ready solution.

Imports IronPdf



' This script uses the IronPdf library to render a webpage as a PDF document.



' Create an instance of ChromePdfRenderer, which uses a headless version of Chrome

' to accurately render HTML content into a PDF format.

Private renderer = New ChromePdfRenderer()



' Call the RenderUrlAsPdf method on the renderer object with a specific URL.

' The URL leads to a D3.js data visualization, which will be fetched and rendered as a PDF.

Private pdf = renderer.RenderUrlAsPdf("https://bl.ocks.org/mbostock/4062006")



' After the PDF is rendered, save it to the local filesystem.

' The PDF document will be saved with the name "chart.pdf" in the current working directory.

pdf.SaveAs("chart.pdf")



' Note: 

' - Ensure that the IronPdf NuGet package is installed and referenced in your project to access these functionalities.

' - The URL must be accessible publicly. Ensure network connectivity for the URL to fetch the content successfully.

' - Handle any exceptions that may arise during the execution for a production-ready solution.

// This line of code sets the CSS media type for PDF rendering to 'Print'.
// It's used when rendering PDF documents with IronPdf to apply specific styles that are optimized for print media.
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

' This line of code sets the CSS media type for PDF rendering to 'Print'.

' It's used when rendering PDF documents with IronPdf to apply specific styles that are optimized for print media.

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

// Import the IronPdf library to work with PDF files
using IronPdf;

// Instantiate a ChromePdfRenderer, which will be used to render HTML to PDF.
var renderer = new ChromePdfRenderer();

// Render the HTML content from the specified HTML file into a PDF document.
// 'RenderHtmlFileAsPdf' method takes a file path to an HTML document and converts it to PDF.
var pdf = renderer.RenderHtmlFileAsPdf("Assets/TestInvoice1.html");

// Save the generated PDF to a file called "Invoice.pdf" in the current working directory.
// The 'SaveAs' method takes a string file path where the PDF will be saved.
pdf.SaveAs("Invoice.pdf");

' Import the IronPdf library to work with PDF files

Imports IronPdf



' Instantiate a ChromePdfRenderer, which will be used to render HTML to PDF.

Private renderer = New ChromePdfRenderer()



' Render the HTML content from the specified HTML file into a PDF document.

' 'RenderHtmlFileAsPdf' method takes a file path to an HTML document and converts it to PDF.

Private pdf = renderer.RenderHtmlFileAsPdf("Assets/TestInvoice1.html")



' Save the generated PDF to a file called "Invoice.pdf" in the current working directory.

' The 'SaveAs' method takes a string file path where the PDF will be saved.

pdf.SaveAs("Invoice.pdf")

using IronPdf;

// Create a PDF from an existing HTML file with specified rendering options
var renderer = new ChromePdfRenderer
{
    // Set rendering options such as margins, CSS media type, and header/footer details
    RenderingOptions = new PdfDocumentOptions
    {
        // Margins in millimeters
        MarginTop = 50,
        MarginBottom = 50,

        // Set CSS media type to 'Print'
        CssMediaType = PdfCssMediaType.Print,

        // Define header details
        TextHeader = new HtmlHeaderFooter
        {
            CenterText = "{pdf-title}", // Title of the PDF
            DrawDividerLine = true, // Draw a line below the header
            FontSize = 16 // Font size for header content
        },

        // Define footer details
        TextFooter = new HtmlHeaderFooter
        {
            LeftText = "{date} {time}", // Show the current date and time on the left
            RightText = "Page {page} of {total-pages}", // Show pagination on the right
            DrawDividerLine = true, // Draw a line above the footer
            FontSize = 14 // Font size for footer content
        }
    }
};

// Render the HTML from the specified file as a PDF document
var pdf = renderer.RenderHtmlFileAsPdf("assets/TestInvoice1.html");

// Save the rendered PDF to the specified file path
pdf.SaveAs("Invoice.pdf");

// Open the generated PDF file using the default PDF viewer
System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
{
    FileName = "Invoice.pdf",
    UseShellExecute = true
});

Imports IronPdf



' Create a PDF from an existing HTML file with specified rendering options

Private renderer = New ChromePdfRenderer With {

	.RenderingOptions = New PdfDocumentOptions With {

		.MarginTop = 50, .MarginBottom = 50, .CssMediaType = PdfCssMediaType.Print, .TextHeader = New HtmlHeaderFooter With {

			.CenterText = "{pdf-title}",

			.DrawDividerLine = True,

			.FontSize = 16

		},

		.TextFooter = New HtmlHeaderFooter With {

			.LeftText = "{date} {time}",

			.RightText = "Page {page} of {total-pages}",

			.DrawDividerLine = True,

			.FontSize = 14

		}

	}

}



' Render the HTML from the specified file as a PDF document

Private pdf = renderer.RenderHtmlFileAsPdf("assets/TestInvoice1.html")



' Save the rendered PDF to the specified file path

pdf.SaveAs("Invoice.pdf")



' Open the generated PDF file using the default PDF viewer

System.Diagnostics.Process.Start(New System.Diagnostics.ProcessStartInfo With {

	.FileName = "Invoice.pdf",

	.UseShellExecute = True

})

using IronPdf;

// The following code sets up a footer for a PDF using IronPdf, a library for rendering HTML to PDF.
// The footer is configured to show the current page number and total number of pages, formatted with HTML.
// It uses HtmlHeaderFooter to set the footer content with HTML and styling.

// Create an instance of the HtmlToPdf renderer
HtmlToPdf renderer = new HtmlToPdf();

// Configure the rendering options for the PDF
renderer.RenderingOptions.Footer = new HtmlHeaderFooter()
{
    // Define the HTML content for the footer
    HtmlFragment = "<div style='text-align:right'><em style='color:pink'>page {page} of {total-pages}</em></div>"
    // The {page} and {total-pages} are special tokens that will be replaced by
    // the current page number and the total number of pages in the PDF, respectively.
};

Imports IronPdf



' The following code sets up a footer for a PDF using IronPdf, a library for rendering HTML to PDF.

' The footer is configured to show the current page number and total number of pages, formatted with HTML.

' It uses HtmlHeaderFooter to set the footer content with HTML and styling.



' Create an instance of the HtmlToPdf renderer

Private renderer As New HtmlToPdf()



' Configure the rendering options for the PDF

renderer.RenderingOptions.Footer = New HtmlHeaderFooter() With {.HtmlFragment = "<div style='text-align:right'><em style='color:pink'>page {page} of {total-pages}</em></div>"}

// Import the IronPdf namespace to access the required classes and methods
using IronPdf;

// Instantiate a new HtmlToPdf renderer from the IronPdf library
var renderer = new HtmlToPdf();

// Set the CSS media type rendering option to 'Print' for the PDF renderer
// This ensures that print-specific CSS styles are applied during rendering
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Generate a PDF from HTML content and save it to a file
// The RenderHtmlAsPdf method converts an HTML string to a PDF document
// The SaveAs method saves the PDF document to the specified file path
renderer.RenderHtmlAsPdf("<html><body><h1>Hello, World!</h1></body></html>").SaveAs("Output.pdf");

' Import the IronPdf namespace to access the required classes and methods

Imports IronPdf



' Instantiate a new HtmlToPdf renderer from the IronPdf library

Private renderer = New HtmlToPdf()



' Set the CSS media type rendering option to 'Print' for the PDF renderer

' This ensures that print-specific CSS styles are applied during rendering

renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print



' Generate a PDF from HTML content and save it to a file

' The RenderHtmlAsPdf method converts an HTML string to a PDF document

' The SaveAs method saves the PDF document to the specified file path

renderer.RenderHtmlAsPdf("<html><body><h1>Hello, World!</h1></body></html>").SaveAs("Output.pdf")

// Import necessary namespaces
using IronPdf;

// Create an HtmlToPdf renderer instance
var renderer = new HtmlToPdf();

// Set the top margin for the rendered PDF in millimeters
renderer.PrintOptions.MarginTop = 50;

// Set the bottom margin for the rendered PDF in millimeters
renderer.PrintOptions.MarginBottom = 50;

// Render an HTML document as PDF example:
// var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
// The result 'pdf' can be saved or manipulated further
// Example: pdf.SaveAs("output.pdf");

' Import necessary namespaces

Imports IronPdf



' Create an HtmlToPdf renderer instance

Private renderer = New HtmlToPdf()



' Set the top margin for the rendered PDF in millimeters

renderer.PrintOptions.MarginTop = 50



' Set the bottom margin for the rendered PDF in millimeters

renderer.PrintOptions.MarginBottom = 50



' Render an HTML document as PDF example:

' var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");

' The result 'pdf' can be saved or manipulated further

' Example: pdf.SaveAs("output.pdf");

// Import the IronPdf library to work with PDF operations.
using IronPdf;

// Create a PdfRenderer object to manage PDF rendering options.
PdfRenderer renderer = new PdfRenderer();

// Set rendering options for the PdfRenderer.
// Specifically, enable the printing of HTML backgrounds in the generated PDF documents.
renderer.RenderingOptions.PrintHtmlBackgrounds = true;

// This is where you would continue with your PDF rendering logic based on your needs,
// such as creating a PDF from HTML, rendering to a specific file, etc.

// For instance, to render an HTML string into a PDF:
string htmlContent = "<h1>Hello, PDF!</h1><p>This is a PDF document rendered from HTML content.</p>";
// Specify the output path for the generated PDF document.
string outputPath = "output.pdf";

// Render the HTML content to the specified PDF file.
PdfDocument pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
pdfDocument.SaveAs(outputPath);

// Inform the user about the successful creation of the PDF file.
Console.WriteLine($"PDF document successfully created at: {outputPath}");

' Import the IronPdf library to work with PDF operations.

Imports IronPdf



' Create a PdfRenderer object to manage PDF rendering options.

Private renderer As New PdfRenderer()



' Set rendering options for the PdfRenderer.

' Specifically, enable the printing of HTML backgrounds in the generated PDF documents.

renderer.RenderingOptions.PrintHtmlBackgrounds = True



' This is where you would continue with your PDF rendering logic based on your needs,

' such as creating a PDF from HTML, rendering to a specific file, etc.



' For instance, to render an HTML string into a PDF:

Dim htmlContent As String = "<h1>Hello, PDF!</h1><p>This is a PDF document rendered from HTML content.</p>"

' Specify the output path for the generated PDF document.

Dim outputPath As String = "output.pdf"



' Render the HTML content to the specified PDF file.

Dim pdfDocument As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

pdfDocument.SaveAs(outputPath)



' Inform the user about the successful creation of the PDF file.

Console.WriteLine($"PDF document successfully created at: {outputPath}")

using IronPdf;
using IronPdf.Rendering;

// Create an instance of the HtmlToPdf renderer
var renderer = new HtmlToPdf();

/* 
   Set the rendering options for the PDF:
   - PaperSize: Sets the paper size to A4.
   - PaperOrientation: Sets the paper orientation to Landscape.
*/
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;

// Additional code for generating a PDF should be added here. For example:
// var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
// pdf.SaveAs("output.pdf");

// The above example shows how you might render an HTML string to a PDF and save it to a file.

Imports IronPdf

Imports IronPdf.Rendering



' Create an instance of the HtmlToPdf renderer

Private renderer = New HtmlToPdf()



' 

'   Set the rendering options for the PDF:

'   - PaperSize: Sets the paper size to A4.

'   - PaperOrientation: Sets the paper orientation to Landscape.

'

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape



' Additional code for generating a PDF should be added here. For example:

' var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

' pdf.SaveAs("output.pdf");



' The above example shows how you might render an HTML string to a PDF and save it to a file.

using System;

// Define a class named 'Program' containing the main entry point of the application
class Program
{
    // The main entry point for the application
    static void Main()
    {
        // The following line formats a string to include the word "World"
        // in place of the placeholder {0} and enclose it within <h1> HTML tags
        string formattedString = String.Format("<h1>Hello {0}!</h1>", "World");

        // Output the formatted string to the console
        Console.WriteLine(formattedString);
    }
}

Imports System



' Define a class named 'Program' containing the main entry point of the application

Friend Class Program

	' The main entry point for the application

	Shared Sub Main()

		' The following line formats a string to include the word "World"

		' in place of the placeholder {0} and enclose it within <h1> HTML tags

		Dim formattedString As String = String.Format("<h1>Hello {0}!</h1>", "World")



		' Output the formatted string to the console

		Console.WriteLine(formattedString)

	End Sub

End Class

// Define a basic HTML template with a placeholder for names
var htmlTemplate = "<p>[[NAME]]</p>";

// Create an array containing names to be inserted into the HTML template
var names = new[] { "John", "James", "Jenny" };

// Iterate over each name in the names array
foreach (var name in names)
{
    // Replace the placeholder in the HTML template with the current name
    var htmlInstance = htmlTemplate.Replace("[[NAME]]", name);

    // Render the HTML string to a PDF object
    // Assume 'renderer' is a pre-configured instance of a PDF rendering library
    var pdf = renderer.RenderHtmlAsPdf(htmlInstance);

    // Save the rendered PDF file with the name of the person
    pdf.SaveAs(name + ".pdf");
}

' Define a basic HTML template with a placeholder for names

Dim htmlTemplate = "<p>[[NAME]]</p>"



' Create an array containing names to be inserted into the HTML template

Dim names = { "John", "James", "Jenny" }



' Iterate over each name in the names array

For Each name In names

	' Replace the placeholder in the HTML template with the current name

	Dim htmlInstance = htmlTemplate.Replace("[[NAME]]", name)



	' Render the HTML string to a PDF object

	' Assume 'renderer' is a pre-configured instance of a PDF rendering library

	Dim pdf = renderer.RenderHtmlAsPdf(htmlInstance)



	' Save the rendered PDF file with the name of the person

	pdf.SaveAs(name & ".pdf")

Next name

using HandlebarsDotNet;

// Define the source template as a string with placeholders for title and body
var source = 
    @"<div class=""entry"">
        <h1>{{title}}</h1>
        <div class=""body"">
            {{body}}
        </div>
    </div>";

// Compile the Handlebars template from the source string
var template = Handlebars.Compile(source);

// Create an anonymous type representing the data with properties `title` and `body`
var data = new { title = "My new post", body = "This is my first post!" };

// Execute the compiled template with the given data to produce the result string
var result = template(data);

// The resulting HTML will look like this:
// 
// <div class="entry">
//   <h1>My new post</h1>
//   <div class="body">
//     This is my first post!
//   </div>
// </div>

// Output the result to the console
Console.WriteLine(result);

Imports HandlebarsDotNet



' Define the source template as a string with placeholders for title and body

Private source = "<div class=""entry"">

        <h1>{{title}}</h1>

        <div class=""body"">

            {{body}}

        </div>

    </div>"



' Compile the Handlebars template from the source string

Private template = Handlebars.Compile(source)



' Create an anonymous type representing the data with properties `title` and `body`

Private data = New With {

	Key .title = "My new post",

	Key .body = "This is my first post!"

}



' Execute the compiled template with the given data to produce the result string

Private result = template(data)



' The resulting HTML will look like this:

' 

' <div class="entry">

'   <h1>My new post</h1>

'   <div class="body">

'     This is my first post!

'   </div>

' </div>



' Output the result to the console

Console.WriteLine(result)

using IronPdf;

// Create an instance of the ChromePdfRenderer, which allows rendering HTML to PDF.
var renderer = new ChromePdfRenderer();

// Define the HTML content you wish to convert to PDF.
string htmlInstance = "<html><body><h1>Hello, World!</h1></body></html>"; // Example HTML content

// Render the HTML content as a PDF document.
var pdf = renderer.RenderHtmlAsPdf(htmlInstance);

// Save the rendered PDF document to a file named "Handlebars.pdf".
pdf.SaveAs("Handlebars.pdf");

Imports IronPdf



' Create an instance of the ChromePdfRenderer, which allows rendering HTML to PDF.

Private renderer = New ChromePdfRenderer()



' Define the HTML content you wish to convert to PDF.

Private htmlInstance As String = "<html><body><h1>Hello, World!</h1></body></html>" ' Example HTML content



' Render the HTML content as a PDF document.

Private pdf = renderer.RenderHtmlAsPdf(htmlInstance)



' Save the rendered PDF document to a file named "Handlebars.pdf".

pdf.SaveAs("Handlebars.pdf")

<div style='page-break-after: always;'>&nbsp;</div>

<!DOCTYPE html>
<html>
  <head>
    <style type="text/css" media="print">
      .page {
        page-break-after: always;
        page-break-inside: avoid;
      }
    </style>
  </head>
  <body>
    <div class="page">
      <h1>This is Page 1</h1>
    </div>
    <div class="page">
      <h1>This is Page 2</h1>
    </div>
    <div class="page">
      <h1>This is Page 3</h1>
    </div>
  </body>
</html>

// Import the IronPdf library, which provides tools for generating and manipulating PDF documents
using IronPdf;

// Create an instance of the HtmlToPdf class, which is used for converting HTML content into PDF format
var renderer = new HtmlToPdf();

// Render a PDF document from a specific URL
// This line creates a PDF document from the contents of the given URL
var pdf = renderer.RenderUrlAsPdf("https://www.nuget.org/packages/IronPdf/");

// Merge the newly created PDF with another PDF document named "CoverPage.pdf"
// The PdfDocument.Merge method combines multiple PDF documents into a single document
var pdfMerged = PdfDocument.Merge(new PdfDocument("CoverPage.pdf"), pdf);

// Save the merged PDF document as "Combined.Pdf"
pdfMerged.SaveAs("Combined.Pdf");

// Note:
// 1. The code assumes that "CoverPage.pdf" is already available in the working directory.
// 2. The method PdfDocument.Merge returns a new PdfDocument object that represents the merged PDFs.
// 3. Make sure you have the IronPdf library installed and referenced in your project for this code to work.

' Import the IronPdf library, which provides tools for generating and manipulating PDF documents

Imports IronPdf



' Create an instance of the HtmlToPdf class, which is used for converting HTML content into PDF format

Private renderer = New HtmlToPdf()



' Render a PDF document from a specific URL

' This line creates a PDF document from the contents of the given URL

Private pdf = renderer.RenderUrlAsPdf("https://www.nuget.org/packages/IronPdf/")



' Merge the newly created PDF with another PDF document named "CoverPage.pdf"

' The PdfDocument.Merge method combines multiple PDF documents into a single document

Private pdfMerged = PdfDocument.Merge(New PdfDocument("CoverPage.pdf"), pdf)



' Save the merged PDF document as "Combined.Pdf"

pdfMerged.SaveAs("Combined.Pdf")



' Note:

' 1. The code assumes that "CoverPage.pdf" is already available in the working directory.

' 2. The method PdfDocument.Merge returns a new PdfDocument object that represents the merged PDFs.

' 3. Make sure you have the IronPdf library installed and referenced in your project for this code to work.

// Import necessary namespaces for IronPdf
using IronPdf;
using IronPdf.Editing;

// Instantiate the ChromePdfRenderer, which allows rendering HTML/CSS/JavaScript content to a PDF
var renderer = new ChromePdfRenderer();

// Render a PDF from a URL. The specified URL is that of a NuGet package page for IronPdf.
var pdf = renderer.RenderUrlAsPdf("https://www.nuget.org/packages/IronPdf");

// Create a text watermark to apply to all pages of the PDF.
// The watermark text is "SAMPLE", styled in red, and positioned at the center of each page.
var watermark = new TextWatermark()
{
    FontSize = 50, // Set font size for the watermark text
    Text = "SAMPLE", // The watermark text
    HorizontalAlignment = HorizontalAlignment.Center, // Horizontally align the watermark to the center
    VerticalAlignment = VerticalAlignment.Middle, // Vertically align the watermark to the middle
    FontColor = IronPdf.Drawing.Colors.Red // Font color set to red
};

// Apply the watermark to all pages of the PDF
pdf.Watermark = watermark;

// Save the watermarked PDF to the specified path
pdf.SaveAs(@"C:\Path\To\Watermarked.pdf");

' Import necessary namespaces for IronPdf

Imports IronPdf

Imports IronPdf.Editing



' Instantiate the ChromePdfRenderer, which allows rendering HTML/CSS/JavaScript content to a PDF

Private renderer = New ChromePdfRenderer()



' Render a PDF from a URL. The specified URL is that of a NuGet package page for IronPdf.

Private pdf = renderer.RenderUrlAsPdf("https://www.nuget.org/packages/IronPdf")



' Create a text watermark to apply to all pages of the PDF.

' The watermark text is "SAMPLE", styled in red, and positioned at the center of each page.

Private watermark = New TextWatermark() With {

	.FontSize = 50,

	.Text = "SAMPLE",

	.HorizontalAlignment = HorizontalAlignment.Center,

	.VerticalAlignment = VerticalAlignment.Middle,

	.FontColor = IronPdf.Drawing.Colors.Red

}



' Apply the watermark to all pages of the PDF

pdf.Watermark = watermark



' Save the watermarked PDF to the specified path

pdf.SaveAs("C:\Path\To\Watermarked.pdf")