Skip to main content

HTML to PDF in C#/.NET with iText 7

· 17 min read
Michał Szymanowski
Michał Szymanowski
PDFBolt Co-Founder

Convert HTML to PDF using iText 7 in C#/.NET

Need to generate professional PDFs from HTML in C# applications? This comprehensive guide shows you how to implement iText 7 for .NET – the modern, redesigned successor to iTextSharp – with Razor templating for dynamic document generation. Learn to create pixel-perfect invoices, reports, and business documents with precise layout control, leveraging iText 7's clean API and powerful HTML to PDF conversion capabilities through practical, ready-to-use code examples.

What is iText 7 for .NET?​

iText 7 for .NET is a powerful, feature-rich document processing library that enables developers to create, manipulate, and process PDF documents programmatically. As the modern successor to the legacy iTextSharp library (which was the C# port of iText 5), iText 7 has been completely redesigned with a more intuitive object-oriented architecture, making it easier to use while providing more functionality.

Evolution from iTextSharp to iText 7

iText began as a Java library, with iTextSharp serving as its .NET port. While iTextSharp (based on iText 5) is still functional, iText 7 for .NET represents a complete rewrite that offers:

  • A cleaner, more intuitive API.
  • Superior HTML to PDF conversion capabilities.
  • Better performance and memory efficiency.
  • Enhanced typography and layout control.
  • Improved extension mechanisms.
  • More comprehensive internationalization support.

Key Benefits of Using iText 7 for PDF Generation

  • Flexible Document Creation: Generate PDFs from scratch or convert existing content.
  • Advanced Layout Control: Precise positioning, pagination, and content flow management.
  • Rich Text Formatting: Typography, styles, and internationalization support.
  • Data-Driven Content: Seamlessly integrate dynamic data into templates.
  • Document Security: Add encryption, digital signatures, and access controls.
  • Compliance Features: Meet accessibility standards and regulatory requirements.
  • High Performance: Optimized for enterprise-scale document processing.
Licensing Information

iText 7 is available under the AGPL license for open-source projects, which requires applications using it to also be open-source. For commercial applications where you cannot share your source code, commercial licensing options are available from iText Software.

Why Combine iText 7 with Razor Templates?​

The combination of iText 7 with Razor template engine creates a powerful workflow for document generation:

  1. Separation of Design and Logic: Designers can focus on templates while developers handle data integration.
  2. Familiar Syntax: Leverage existing C# skills with Razor's intuitive templating syntax.
  3. Easy Maintenance: Update document designs without modifying core application code.
  4. Reusable Components: Create template libraries that can be shared across different document types.
  5. Dynamic Content Generation: Seamlessly incorporate data from various sources.

This approach offers the best of both worlds: the design flexibility of HTML/CSS and the precise document control of iText 7.

Step-by-Step Implementation: Invoice Generator​

Let's build a complete invoice generation system using iText 7 and Razor templates. This approach can be adapted for any type of document you need to generate.

Step 1: Set Up Your Development Environment​

Before we begin coding, we need to ensure our development environment is properly configured with all necessary tools.

RequirementDetails
IDEVisual Studio, Visual Studio Code or JetBrains Rider
.NET Core/.NET.NET Core/.NET 5/6/7/8/9 (or .NET Framework 4.6.1+)
NuGet Package ManagerFor installing required packages

Step 2: Create a New .NET Project​

Setting up a new project gives us a clean slate to implement our PDF generation solution.

Let's create a new console application:

dotnet new console -n HtmlToPdfGenerator
cd HtmlToPdfGenerator

Or create a new Console Application project through your IDE interface.

Step 3: Configure Project Structure​

A well-organized project structure makes our code more maintainable and easier to navigate.

Set up the following directory structure:

HtmlToPdfGenerator/
├── Program.cs                  # Main application entry point
├── Models/                     # Data models
│   └── InvoiceModel.cs         # Invoice data structure
├── Templates/                  # Razor templates
│   └── Invoice.cshtml          # Invoice template
├── Services/                   # Service classes
│   ├── RazorTemplateService.cs # Template rendering service
│   └── PdfGenerationService.cs # PDF generation service
└── Output/                     # Generated PDFs

Step 4: Install Required NuGet Packages​

These packages provide the core functionality for our PDF generation and templating system.

Add the necessary packages to your project:

dotnet add package itext7
dotnet add package itext7.pdfhtml
dotnet add package RazorLight
info

We've added the following libraries:

  • itext7 - Core library for PDF generation and manipulation.
  • itext7.pdfhtml - HTML to PDF conversion module for iText 7. This is a crucial add-on package as the core iText 7 library does not include HTML conversion functionality on its own. Without this package, you cannot convert HTML to PDF.
  • RazorLight - Template engine for rendering Razor views outside of ASP.NET Core.

Step 5: Create the Invoice Data Model​

Let's create a model to represent our invoice data. This class serves as the structured data container that will populate our Razor templates, providing a strongly-typed approach to document generation.

Add the following class to the Models directory:

InvoiceModel.cs
namespace HtmlToPdfGenerator.Models
{
    // Represents an invoice details
    public class InvoiceModel
    {
        // Required properties
        public required string InvoiceNumber { get; set; }
        public DateTime InvoiceDate { get; set; }
        public DateTime DueDate { get; set; }
        public required string CompanyName { get; set; }
        public required string CompanyAddress { get; set; }
        public required string CompanyEmail { get; set; }
        public required string CompanyPhone { get; set; }
        public required string ClientName { get; set; }
        public required string ClientAddress { get; set; }
        public required string ClientEmail { get; set; }

        // Collection of invoice line items
        public List<InvoiceItem> Items { get; set; } = new List<InvoiceItem>();

        // Other invoice properties
        public decimal TaxRate { get; set; }
        public string Currency { get; set; } = "$";
        public string? Notes { get; set; }

        // Calculated properties
        public decimal Subtotal => Items.Sum(item => item.Total);
        public decimal TaxAmount => Math.Round(Subtotal * (TaxRate / 100), 2);
        public decimal Total => Subtotal + TaxAmount;
    }

    public class InvoiceItem
    {
        public required string Description { get; set; }
        public int Quantity { get; set; }
        public decimal UnitPrice { get; set; }
        public decimal Total => Quantity * UnitPrice;
    }
}

Step 6: Create the Razor Template for the Invoice​

The Razor template defines the visual layout of our invoice, combining HTML/CSS with dynamic data from our model. So let's design our invoice template using Razor syntax.

Create a file named Invoice.cshtml in the Templates directory:

Invoice.cshtml Template
@model HtmlToPdfGenerator.Models.InvoiceModel
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Invoice @Model.InvoiceNumber</title>
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, sans-serif;
            font-size: 13px;
            color: #333;
            margin: 0;
            padding: 0;
        }

        .invoice-container {
            max-width: 900px;
            padding: 40px;
            background-color: #fff;
        }

        .invoice-header {
            position: relative;
            margin-bottom: 40px;
            padding-bottom: 50px;
            border-bottom: 2px solid #EBE8FA;
        }

        .invoice-title {
            font-size: 40px;
            font-weight: 600;
            color: #660DA7;
        }

        .company-details {
            position: absolute;
            top: 0;
            right: 0;
            text-align: right;
            font-size: 14px;
            line-height: 1.6;
        }

        .invoice-details {
            display: flex;
            justify-content: space-between;
            margin-bottom: 30px;
        }

        .client-info, .invoice-info {
            flex: 1;
        }

        .section-title {
            font-size: 18px;
            font-weight: 600;
            color: #660DA7;
            margin-bottom: 10px;
            border-bottom: 1px solid #EBE8FA;
            padding-bottom: 5px;
        }

        .invoice-table {
            width: 100%;
            border-collapse: collapse;
            margin-bottom: 25px;
        }

        .invoice-table th {
            background-color: #660DA7;
            font-size: 16px;
            color: #fff;
            font-weight: 600;
            padding: 10px;
            text-align: left;
        }

        .invoice-table td {
            padding: 10px;
            border-bottom: 1px solid #e0e0e0;
        }

        .invoice-table tr:last-child td {
            border-bottom: none;
        }

        .invoice-table tr:nth-child(even) {
            background-color: #f9f9f9;
        }

        .summary-table {
            width: 100%;
            max-width: 350px;
            margin-left: auto;
            border-collapse: collapse;
            margin-bottom: 30px;
        }

        .summary-table td {
            padding: 8px 10px;
        }

        .summary-table tr:last-child td {
            background-color: #f3f2f9;
            font-weight: bold;
            font-size: 15px;
            border-top: 2px solid #660DA7;
        }

        .notes {
            padding: 20px;
            background-color: #f3f2f9;
            border-left: 4px solid #660DA7;
            margin-top: 20px;
            border-radius: 4px;
        }

        .footer {
            text-align: center;
            color: #999;
            font-size: 12px;
            padding-top: 20px;
            border-top: 1px solid #EBE8FA;
            margin-top: 40px;
        }

        .text-right {
            text-align: right;
        }
    </style>
</head>
<body>
<div class="invoice-container">
    <div class="invoice-header">
        <div class="invoice-title">INVOICE</div>
        <div class="company-details">
            <div><strong>@Model.CompanyName</strong></div>
            <div>@Model.CompanyAddress</div>
            <div>Email: @Model.CompanyEmail</div>
            <div>Phone: @Model.CompanyPhone</div>
        </div>
    </div>

    <div class="invoice-details">
        <div class="client-info">
            <div class="section-title">Bill To</div>
            <div><strong>@Model.ClientName</strong></div>
            <div>@Model.ClientAddress</div>
            <div>@Model.ClientEmail</div>
        </div>
        <div class="invoice-info">
            <div class="section-title">Invoice Details</div>
            <table style="width: 100%;">
                <tr>
                    <td><strong>Invoice #:</strong></td>
                    <td>@Model.InvoiceNumber</td>
                </tr>
                <tr>
                    <td><strong>Issue Date:</strong></td>
                    <td>@Model.InvoiceDate.ToString("MMMM dd, yyyy", System.Globalization.CultureInfo.InvariantCulture)</td>
                </tr>
                <tr>
                    <td><strong>Due Date:</strong></td>
                    <td>@Model.DueDate.ToString("MMMM dd, yyyy", System.Globalization.CultureInfo.InvariantCulture)</td>
                </tr>
            </table>
        </div>
    </div>

    <table class="invoice-table">
        <thead>
        <tr>
            <th>Description</th>
            <th>Quantity</th>
            <th>Unit Price</th>
            <th class="text-right">Amount</th>
        </tr>
        </thead>
        <tbody>
        @foreach (var item in Model.Items)
        {
        <tr>
            <td>@item.Description</td>
            <td>@item.Quantity</td>
            <td>@[email protected]("0.00")</td>
            <td class="text-right">@[email protected]("0.00")</td>
        </tr>
        }
        </tbody>
    </table>

    <table class="summary-table">
        <tr>
            <td>Subtotal:</td>
            <td class="text-right">@[email protected]("0.00")</td>
        </tr>
        <tr>
            <td>Tax (@Model.TaxRate%):</td>
            <td class="text-right">@[email protected]("0.00")</td>
        </tr>
        <tr>
            <td>Total:</td>
            <td class="text-right">@[email protected]("0.00")</td>
        </tr>
    </table>

    @if (!string.IsNullOrEmpty(Model.Notes))
    {
    <div class="notes">
        <div class="section-title">Notes</div>
        <div>@Model.Notes</div>
    </div>
    }

    <div class="footer">
        Thank you for your business!
    </div>
</div>
</body>
</html>

This template uses clean, professional styling with CSS for a polished invoice layout. The Razor syntax (@Model.PropertyName) enables dynamic content insertion from our data model.

Step 7: Create the Razor Template Service​

This service handles the rendering of Razor templates with our data models, converting them to HTML.

Create RazorTemplateService.cs in the Services directory:

RazorTemplateService.cs
using RazorLight;

namespace HtmlToPdfGenerator.Services
{
    // Service for rendering Razor templates to HTML
    public class RazorTemplateService
    {
        private readonly RazorLightEngine _engine;

        public RazorTemplateService()
        {
            // Initialize the RazorLight engine
            _engine = new RazorLightEngineBuilder()
                // Set the root directory for template resolution
                .UseFileSystemProject(Directory.GetCurrentDirectory())
                // Enable caching for better performance
                .UseMemoryCachingProvider()
                .Build();
        }

        // Renders a Razor template file with the provided model data
        public async Task<string> RenderTemplateAsync<T>(string templatePath, T model)
        {
            try
            {
                // Validate template file exists
                if (!File.Exists(templatePath))
                {
                    throw new FileNotFoundException($"Template file not found: {templatePath}");
                }

                // Read the template content from file
                string templateContent = await File.ReadAllTextAsync(templatePath);

                // Generate a unique key for the template
                string templateKey = GetHashString(templatePath);

                // Process the template with the provided model
                string result = await _engine.CompileRenderStringAsync(templateKey, templateContent, model);

                return result;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Template rendering error: {ex.Message}");
                throw; // Re-throw to allow handling at a higher level
            }
        }

        // Helper method to generate a hash for template caching
        private static string GetHashString(string text)
        {
            using (var sha = System.Security.Cryptography.SHA256.Create())
            {
                var bytes = System.Text.Encoding.UTF8.GetBytes(text);
                var hash = sha.ComputeHash(bytes);
                return Convert.ToBase64String(hash);
            }
        }
    }
}

Step 8: Create the PDF Generation Service with iText 7​

Now, let's implement the service that converts HTML to PDF using iText 7.

Create PdfGenerationService.cs in the Services directory:

PdfGenerationService.cs
using iText.Html2pdf;
using iText.Html2pdf.Resolver.Font;
using iText.Kernel.Geom;
using iText.Kernel.Pdf;
using Path = System.IO.Path;

namespace HtmlToPdfGenerator.Services
{
    // Service for converting HTML content to PDF using iText 7
    public class PdfGenerationService
    {
        // Converts HTML content to PDF and saves it
        public void GeneratePdfFromHtml(string htmlContent, string outputPath, PdfSettings settings = null)
        {
            // Use default settings if none provided
            settings ??= new PdfSettings();

            try
            {
                // Create output directory if it doesn't exist
                string? directory = Path.GetDirectoryName(outputPath);
                if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
                {
                    Directory.CreateDirectory(directory);
                }

                // Use a FileStream for better control and reliability
                using (var stream = new FileStream(outputPath, FileMode.Create, FileAccess.Write))
                {
                    // Create PDF writer with the stream
                    using (var writer = new PdfWriter(stream))
                    {
                        // Create PDF document
                        using (var pdf = new PdfDocument(writer))
                        {
                            // Set page size
                            pdf.SetDefaultPageSize(settings.PageSize);

                            // Configure HTML to PDF converter
                            ConverterProperties converterProperties = new ConverterProperties();

                            // Set base URI for resource resolution if provided
                            if (!string.IsNullOrEmpty(settings.BaseUri))
                            {
                                converterProperties.SetBaseUri(settings.BaseUri);
                            }

                            // Configure font provider
                            converterProperties.SetFontProvider(new DefaultFontProvider(true, true, true));

                            // Apply document metadata if provided
                            if (settings.Metadata != null)
                            {
                                pdf.GetDocumentInfo().SetTitle(settings.Metadata.Title);
                                pdf.GetDocumentInfo().SetAuthor(settings.Metadata.Author);
                                pdf.GetDocumentInfo().SetSubject(settings.Metadata.Subject);
                                pdf.GetDocumentInfo().SetKeywords(settings.Metadata.Keywords);
                                pdf.GetDocumentInfo().SetCreator(settings.Metadata.Creator);
                            }

                            // Convert HTML to PDF
                            HtmlConverter.ConvertToPdf(htmlContent, pdf, converterProperties);
                        }
                    }
                }

                Console.WriteLine($"PDF successfully generated at: {Path.GetFullPath(outputPath)}");
            }
            catch (Exception ex)
            {
                // Enhanced error logging
                Console.WriteLine($"Error generating PDF: {ex.Message}");
                Console.WriteLine($"Inner Exception: {ex.InnerException?.Message}");
                Console.WriteLine($"Stack Trace: {ex.StackTrace}");
                throw; // Re-throw to allow handling at a higher level
            }
        }
    }

    // Settings class for PDF generation customization
    public class PdfSettings
    {
        // Page size (default A4)
        public PageSize PageSize { get; set; } = PageSize.A4;

        // Base URI for resource resolution (images, CSS)
        public string? BaseUri { get; set; }

        // Document metadata
        public DocumentMetadata? Metadata { get; set; }
    }

    // Container for PDF document metadata properties
    public class DocumentMetadata
    {
        public string? Title { get; set; }
        public string? Author { get; set; }
        public string? Subject { get; set; }
        public string? Keywords { get; set; }
        public string? Creator { get; set; }
    }
}

This service handles:

  • The core functionality of converting HTML content to PDF using iText 7's HTML to PDF conversion capabilities.
  • PDF customization through the PdfSettings class, which provides options such as page size and document metadata.

Step 9: Implement the Main Program​

Now, let's tie everything together in the Program.cs file:

Program.cs
using HtmlToPdfGenerator.Models;
using HtmlToPdfGenerator.Services;

namespace HtmlToPdfGenerator
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("Starting HTML to PDF conversion process using iText 7");

            try
            {
                // Define paths for template and output
                string templatePath = Path.Combine("Templates", "Invoice.cshtml");

                // Set output directory
                string outputDir = Path.Combine(
                    Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
                    "RiderProjects",
                    "HtmlToPdfGenerator",
                    "HtmlToPdfGenerator",
                    "Output"
                );

                // Ensure output directory exists
                Directory.CreateDirectory(outputDir);
                Console.WriteLine($"Output directory: {Path.GetFullPath(outputDir)}");

                // 1. Create sample invoice data
                var invoice = CreateSampleInvoice();
                Console.WriteLine($"Created sample invoice with number: {invoice.InvoiceNumber}");

                // 2. Initialize the template rendering service
                var templateService = new RazorTemplateService();
                Console.WriteLine("Template service initialized");

                // 3. Render the HTML from the Razor template
                string html = await templateService.RenderTemplateAsync(templatePath, invoice);
                Console.WriteLine("Template rendered successfully");

                // 4. Save HTML for debugging (optional)
                string htmlOutputPath = Path.Combine(outputDir, $"Invoice_{invoice.InvoiceNumber}.html");
                await File.WriteAllTextAsync(htmlOutputPath, html);
                Console.WriteLine($"HTML saved to: {Path.GetFullPath(htmlOutputPath)}");

                // 5. Initialize the PDF generation service
                var pdfService = new PdfGenerationService();
                Console.WriteLine("PDF service initialized");

                // 6. Configure PDF settings
                var pdfSettings = new PdfSettings
                {
                    // Set base URI for resource resolution
                    BaseUri = Directory.GetCurrentDirectory(),

                    // Set document metadata
                    Metadata = new DocumentMetadata
                    {
                        Title = $"Invoice {invoice.InvoiceNumber}",
                        Author = invoice.CompanyName,
                        Subject = $"Invoice for {invoice.ClientName}",
                        Keywords = "invoice, billing, payment",
                        Creator = "HTML to PDF Generator using iText 7"
                    }
                };

                // 7. Generate the PDF file
                string pdfFileName = $"Invoice_{invoice.InvoiceNumber}.pdf";
                string pdfOutputPath = Path.Combine(outputDir, pdfFileName);

                // Convert HTML to PDF
                pdfService.GeneratePdfFromHtml(html, pdfOutputPath, pdfSettings);
                Console.WriteLine("PDF generation completed successfully!");
                Console.WriteLine($"PDF saved to: {Path.GetFullPath(pdfOutputPath)}");
            }
            catch (Exception ex)
            {
                // Error handling
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"Error: {ex.Message}");
                Console.WriteLine(ex.StackTrace);
                Console.ResetColor();
            }
        }

        // Helper method to create a sample invoice
        private static InvoiceModel CreateSampleInvoice()
        {
            // Generate an invoice number with current year and random number for uniqueness
            string invoiceNumber = $"INV-{DateTime.Now:yyyy}-{new Random().Next(1000, 9999)}";

            // Create sample invoice data
            return new InvoiceModel
            {
                // Invoice information
                InvoiceNumber = invoiceNumber,
                InvoiceDate = DateTime.Now,
                DueDate = DateTime.Now.AddDays(30),

                // Company details
                CompanyName = "PixelPioneers Studios",
                CompanyAddress = "1000 Game Lane, Pixel City, 54321",
                CompanyEmail = "[email protected]",
                CompanyPhone = "+1 (800) 123-4567",

                // Client information
                ClientName = "EpicQuest Games",
                ClientAddress = "123 Guildhall Ave, Fantasy Town",
                ClientEmail = "[email protected]",

                // Payment details
                Currency = "$",
                TaxRate = 7.5m,
                Notes =
                    "Please don't forget to include the invoice number in your quest for payment completion. Game on!",

                // Invoice line items
                Items = new List<InvoiceItem>
                {
                    new InvoiceItem
                    {
                        Description = "Epic Level Design",
                        Quantity = 10,
                        UnitPrice = 125.00m
                    },
                    new InvoiceItem
                    {
                        Description = "Character Animation",
                        Quantity = 4,
                        UnitPrice = 150.00m
                    },
                    new InvoiceItem
                    {
                        Description = "Server Hosting",
                        Quantity = 2,
                        UnitPrice = 175.00m
                    },
                    new InvoiceItem
                    {
                        Description = "VIP Support Package",
                        Quantity = 1,
                        UnitPrice = 750.00m
                    },
                    new InvoiceItem
                    {
                        Description = "Loot Box Creation",
                        Quantity = 5,
                        UnitPrice = 50.00m
                    }
                }
            };
        }
    }
}

The main program orchestrates the entire PDF generation process:

  1. Creates sample invoice data.
  2. Initializes the template service.
  3. Renders the Razor template with data.
  4. Sets up the PDF generation service.
  5. Converts the HTML to PDF.
  6. Handles any errors that might occur.

Step 10: Run the Application​

Execute our program to generate the PDF invoice and verify the results.

With all components in place, you can now run the application:

dotnet run

On success, the PDF will be generated and saved to the Output directory.

Preview of the generated invoice PDF: HTML to PDF conversion using iText 7 in C#/.NET - Invoice

Troubleshooting Common Issues​

When implementing HTML to PDF conversion with iText 7, you might encounter some common issues. Here are solutions to frequently encountered problems:

1. PDF Writer Initialization Errors

Errors with PdfWriter or SmartModePdfObjectsSerializer can often be resolved with these approaches:

➡️ Solution 1: Use FileStream​

Using a FileStream provides better control over file access:

using (var stream = new FileStream(outputPath, FileMode.Create, FileAccess.Write))
{
    using (var writer = new PdfWriter(stream))
    {
        // Your code here
    }
}

➡️ Solution 2: Disable Smart Mode​

Disabling smart mode can prevent serialization issues:

var writerProperties = new WriterProperties();
writerProperties.SetSmartMode(false);
using (var writer = new PdfWriter(outputPath, writerProperties))
{
    // Your code here
}

2. Font and Character Set Issues

If you have problems with fonts or special characters:

➡️ Solution: Configure FontProvider​

Replace the deprecated DefaultFontProvider with a modern FontProvider:

FontProvider fontProvider = new FontProvider();
fontProvider.AddStandardPdfFonts();
fontProvider.AddSystemFonts();

// Optionally: fontProvider.AddFont("path/to/custom-font.ttf");
converterProperties.SetFontProvider(fontProvider);

// Configure character set
properties.SetCharset("UTF-8");

3. CSS Rendering Differences

If your HTML doesn't render as expected in the PDF:

➡️ Solution: Set MediaDeviceDescription​

Configure the media type to align with screen-based CSS rendering:

MediaDeviceDescription mediaDescription = new MediaDeviceDescription(MediaType.SCREEN);
mediaDescription.SetWidth(PageSize.A4.GetWidth());
converterProperties.SetMediaDeviceDescription(mediaDescription);

4. File Access Issues

File access errors can occur due to permissions or invalid paths.

➡️ Solution: Use a Simple Output Path​

Save to a reliable location like the desktop, or ensure the output directory exists:

string outputPath = Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
    $"Invoice_{invoice.InvoiceNumber}.pdf"
);

// Alternatively, create the directory
string outputDir = Path.Combine("Output");
Directory.CreateDirectory(outputDir);
outputPath = Path.Combine(outputDir, $"Invoice_{invoice.InvoiceNumber}.pdf");

Performance Optimization Tips​

For production environments, consider these optimizations:

OptimizationDescriptionImplementation Approach
Template CachingAvoid repeated template compilation.Ensure RazorLight's memory caching is enabled with .UseMemoryCachingProvider() in the engine builder.
Parallel ProcessingGenerate multiple documents simultaneously.Use Parallel.ForEach() with appropriate MaxDegreeOfParallelism for batch processing.
Resource ManagementPrevent memory leaks and resource exhaustionUse proper using statements for all disposable objects (FileStream, PdfWriter, PdfDocument)
Image OptimizationReduce PDF file sizeResize and compress images before including them in documents.
HTML SimplificationImprove conversion performance.Simplify complex HTML/CSS structures for more efficient processing.
Streaming OutputReduce memory usage for large documents.Stream the PDF directly to the output to avoid holding large documents in memory.
Lazy LoadingLoad resources only when needed.Implement lazy loading patterns for resource-intensive components.
Skip the Optimization and Maintenance with HTML to PDF API

You can eliminate these performance concerns and library maintenance entirely by using an HTML to PDF API like PDFBolt. PDFBolt handles all performance optimizations, scaling, and dependency management behind the scenes, allowing you to generate high-quality PDFs without worrying about server resources, library updates, or licensing issues. Simply send your HTML through a straightforward API call and receive a perfectly rendered PDF document in response.

Conclusion​

Converting HTML to PDF using iText 7 in C#/.NET applications provides a robust solution for generating professional documents with precise control. This combination of Razor templates for design and iText 7 for PDF generation creates a flexible, maintainable system perfect for business documents like invoices, reports, and contracts.

While iText 7 offers excellent capability for document generation, it's worth noting that the C# ecosystem provides multiple approaches to HTML to PDF conversion. For web-based layouts with complex JavaScript, you might consider PuppeteerSharp – check out our guide on HTML to PDF conversion using PuppeteerSharp, which offers a Chromium-based alternative that excels with modern web content.

For developers who need pixel-perfect control and deep PDF customization, the iText 7 approach demonstrated in this guide delivers an excellent balance of flexibility and output quality. With these C# techniques, you can build sophisticated document workflows that perfectly match your application's requirements while maintaining full control over the rendering process.

Achievement unlocked: Flawless PDF crafting with Razor and iText 7! 🎮