HTML'yi C# (Geliştirici Kılavuzu) ile PDF'ye Nasıl Dönüştürebilirim?

using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;

public class ReportModel : PageModel
{
    public IActionResult OnGet()
    {
        var renderer = new ChromePdfRenderer();

        // Render a Razor Page directly to PDF
        PdfDocument pdf = renderer.RenderRazorToPdf(this);

        Response.Headers.Add("Content-Disposition", "inline");
        return new FileContentResult(pdf.BinaryData, "application/pdf");
    }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.AspNetCore.Mvc.RazorPages

Public Class ReportModel
    Inherits PageModel

    Public Function OnGet() As IActionResult
        Dim renderer As New ChromePdfRenderer()

        ' Render a Razor Page directly to PDF
        Dim pdf As PdfDocument = renderer.RenderRazorToPdf(Me)

        Response.Headers.Add("Content-Disposition", "inline")
        Return New FileContentResult(pdf.BinaryData, "application/pdf")
    End Function
End Class

using IronPdf.Extensions.Mvc.Core;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();

// Register the Razor view renderer for IronPDF
builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
builder.Services.AddSingleton<IRazorViewRenderer, RazorViewRenderer>();

Imports IronPdf.Extensions.Mvc.Core

Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllersWithViews()

' Register the Razor view renderer for IronPDF
builder.Services.AddSingleton(Of IHttpContextAccessor, HttpContextAccessor)()
builder.Services.AddSingleton(Of IRazorViewRenderer, RazorViewRenderer)()

using IronPdf;
using IronPdf.Extensions.Mvc.Core;
using Microsoft.AspNetCore.Mvc;

public class ReportController : Controller
{
    private readonly IRazorViewRenderer _viewRenderService;

    // Inject the view renderer via constructor
    public ReportController(IRazorViewRenderer viewRenderService)
    {
        _viewRenderService = viewRenderService;
    }

    public IActionResult Download()
    {
        var reportModel = new { Title = "Quarterly Report", Total = 1250.00 };
        var renderer = new ChromePdfRenderer();

        // Render an MVC View with model data to PDF
        PdfDocument pdf = renderer.RenderRazorViewToPdf(
            _viewRenderService, "Views/Home/Report.cshtml", reportModel);

        Response.Headers.Add("Content-Disposition", "inline");
        return new FileContentResult(pdf.BinaryData, "application/pdf");
    }
}

Imports IronPdf
Imports IronPdf.Extensions.Mvc.Core
Imports Microsoft.AspNetCore.Mvc

Public Class ReportController
    Inherits Controller

    Private ReadOnly _viewRenderService As IRazorViewRenderer

    ' Inject the view renderer via constructor
    Public Sub New(viewRenderService As IRazorViewRenderer)
        _viewRenderService = viewRenderService
    End Sub

    Public Function Download() As IActionResult
        Dim reportModel = New With {.Title = "Quarterly Report", .Total = 1250.0}
        Dim renderer = New ChromePdfRenderer()

        ' Render an MVC View with model data to PDF
        Dim pdf As PdfDocument = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Home/Report.cshtml", reportModel)

        Response.Headers.Add("Content-Disposition", "inline")
        Return New FileContentResult(pdf.BinaryData, "application/pdf")
    End Function
End Class

using IronPdf;

var renderer = new ChromePdfRenderer();

// Network authentication (Basic, Digest, NTLM)
renderer.LoginCredentials = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "securePassword"
};

// Session cookies for authenticated pages
renderer.RenderingOptions.CustomCookies["sessionId"] = "abc123";

// Custom HTTP headers (e.g., Bearer tokens, API keys)
renderer.RenderingOptions.CustomHttpRequestHeaders["Authorization"] = "Bearer eyJhbGciOi...";

var pdf = renderer.RenderUrlAsPdf("https://intranet.com/pany.com/quarterly-report");
pdf.SaveAs("quarterly-report.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Network authentication (Basic, Digest, NTLM)
renderer.LoginCredentials = New ChromeHttpLoginCredentials With {
    .NetworkUsername = "user@domain.com",
    .NetworkPassword = "securePassword"
}

' Session cookies for authenticated pages
renderer.RenderingOptions.CustomCookies("sessionId") = "abc123"

' Custom HTTP headers (e.g., Bearer tokens, API keys)
renderer.RenderingOptions.CustomHttpRequestHeaders("Authorization") = "Bearer eyJhbGciOi..."

Dim pdf = renderer.RenderUrlAsPdf("https://intranet.com/pany.com/quarterly-report")
pdf.SaveAs("quarterly-report.pdf")

using IronPdf;

var renderer = new ChromePdfRenderer();

// Proxy is the third parameter, not a render option
var pdf = renderer.RenderHtmlAsPdf(
    "<h1>Report</h1><link rel='stylesheet' href='https://cdn.example.com/styles.css'>",
    baseUrlOrPath: null,
    proxy: "http://proxy.co/rp.local:8080"
);
pdf.SaveAs("proxied-report.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Proxy is the third parameter, not a render option
Dim pdf = renderer.RenderHtmlAsPdf(
    "<h1>Report</h1><link rel='stylesheet' href='https://cdn.example.com/styles.css'>",
    baseUrlOrPath:=Nothing,
    proxy:="http://proxy.co/rp.local:8080"
)
pdf.SaveAs("proxied-report.pdf")

// Simple HTML templating with String.Format
string htmlTemplate = String.Format("<h1>Hello {0}!</h1>", "World");

// Results in HTML content: <h1>Hello World!</h1>

' Simple HTML templating with String.Format
Dim htmlTemplate As String = String.Format("<h1>Hello {0}!</h1>", "World")

' Results in HTML content: <h1>Hello World!</h1>

using IronPdf;

// Define reusable HTML template for PDF files
var htmlTemplate = "<p>Dear [[NAME]],</p><p>Thank you for your order.</p>";

// Customer names for batch PDF conversion processing
var names = new[] { "John", "James", "Jenny" };

// Create personalized PDF documents for each customer
var renderer = new ChromePdfRenderer();

foreach (var name in names)
{
    // Replace placeholder with actual data in HTML string
    var htmlInstance = htmlTemplate.Replace("[[NAME]]", name);

    // Generate personalized PDF document from HTML content
    var pdf = renderer.RenderHtmlAsPdf(htmlInstance);

    // Save with customer-specific filename as PDF files
    pdf.SaveAs($"{name}-invoice.pdf");
}

Imports IronPdf

' Define reusable HTML template for PDF files
Dim htmlTemplate As String = "<p>Dear [[NAME]],</p><p>Thank you for your order.</p>"

' Customer names for batch PDF conversion processing
Dim names As String() = {"John", "James", "Jenny"}

' Create personalized PDF documents for each customer
Dim renderer As New ChromePdfRenderer()

For Each name In names
    ' Replace placeholder with actual data in HTML string
    Dim htmlInstance As String = htmlTemplate.Replace("[[NAME]]", name)

    ' Generate personalized PDF document from HTML content
    Dim pdf = renderer.RenderHtmlAsPdf(htmlInstance)

    ' Save with customer-specific filename as PDF files
    pdf.SaveAs($"{name}-invoice.pdf")
Next

# First, install Handlebars.NET for HTML to PDF templating
PM > Install-Paket Handlebars.NET

using HandlebarsDotNet;
using IronPdf;

// Define Handlebars template with placeholders for HTML content
var source = 
    @"<div class=""entry"">
        <h1>{{title}}</h1>
        <div class=""body"">
            {{body}}
        </div>
    </div>";

// Compile template for reuse in PDF conversion
var template = Handlebars.Compile(source);

// Create data object (can be database records) for HTML to PDF directly
var data = new { 
    title = "Monthly Report", 
    body = "Sales increased by 15% this month." 
};

// Merge template with data to create HTML content
var htmlResult = template(data);

// Convert templated HTML to PDF using the PDF converter
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlResult);

pdf.SaveAs("monthly-report.pdf");

Imports HandlebarsDotNet
Imports IronPdf

' Define Handlebars template with placeholders for HTML content
Dim source As String = 
    "<div class=""entry"">
        <h1>{{title}}</h1>
        <div class=""body"">
            {{body}}
        </div>
    </div>"

' Compile template for reuse in PDF conversion
Dim template = Handlebars.Compile(source)

' Create data object (can be database records) for HTML to PDF directly
Dim data = New With { 
    .title = "Monthly Report", 
    .body = "Sales increased by 15% this month." 
}

' Merge template with data to create HTML content
Dim htmlResult = template(data)

' Convert templated HTML to PDF using the PDF converter
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlResult)

pdf.SaveAs("monthly-report.pdf")

<!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>Page 1 Content</h1>
    </div>
    <div class="page">
      <h1>Page 2 Content</h1>
    </div>
    <div class="page">
      <h1>Page 3 Content</h1>
    </div>
  </body>
</html>

using IronPdf;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

public class PdfGenerationService
{
    // Async method for non-blocking PDF generation from HTML content
    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        var renderer = new ChromePdfRenderer();

        // Async HTML to PDF conversion preserves thread pool
        var pdf = await renderer.RenderHtmlAsPdfAsync(html);

        // Return PDF files as byte array for web responses
        return pdf.BinaryData;
    }

    // Concurrent batch PDF generation for multiple HTML strings
    public async Task GenerateMultiplePdfsAsync(List<string> htmlŞablonlar)
    {
        var renderer = new ChromePdfRenderer();

        // Create parallel conversion tasks to generate PDF documents
        var tasks = htmlŞablonlar.Select(html =>
            renderer.RenderHtmlAsPdfAsync(html)
        );

        // Await all PDF conversions simultaneously
        var pdfs = await Task.WhenAll(tasks);

        // Save generated PDF files from HTML content
        for (int i = 0; i < pdfs.Length; i++)
        {
            pdfs[i].SaveAs($"document-{i}.pdf");
        }
    }
}

Imports IronPdf
Imports System.Collections.Generic
Imports System.Linq
Imports System.Threading.Tasks

Public Class PdfGenerationService
    ' Async method for non-blocking PDF generation from HTML content
    Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
        Dim renderer As New ChromePdfRenderer()

        ' Async HTML to PDF conversion preserves thread pool
        Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)

        ' Return PDF files as byte array for web responses
        Return pdf.BinaryData
    End Function

    ' Concurrent batch PDF generation for multiple HTML strings
    Public Async Function GenerateMultiplePdfsAsync(htmlŞablonlar As List(Of String)) As Task
        Dim renderer As New ChromePdfRenderer()

        ' Create parallel conversion tasks to generate PDF documents
        Dim tasks = htmlŞablonlar.Select(Function(html) renderer.RenderHtmlAsPdfAsync(html))

        ' Await all PDF conversions simultaneously
        Dim pdfs = Await Task.WhenAll(tasks)

        ' Save generated PDF files from HTML content
        For i As Integer = 0 To pdfs.Length - 1
            pdfs(i).SaveAs($"document-{i}.pdf")
        Next
    End Function
End Class

using IronPdf;
var renderer = new ChromePdfRenderer();

// Convert HTML to PDF with security
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential Report</h1>");

// Configure security settings for PDF files
pdf.SecuritySettings.UserPassword = "user123";     // Password to open PDF documents
pdf.SecuritySettings.OwnerPassword = "owner456";   // Password to modify PDF files

// Set granular permissions for PDF format
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.PrintLowQuality;

// Apply strong encryption to PDF documents
pdf.SecuritySettings.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256;
pdf.SaveAs("secure-document.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Convert HTML to PDF with security
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Confidential Report</h1>")

' Configure security settings for PDF files
pdf.SecuritySettings.UserPassword = "user123"     ' Password to open PDF documents
pdf.SecuritySettings.OwnerPassword = "owner456"   ' Password to modify PDF files

' Set granular permissions for PDF format
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserAnnotations = False
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.PrintLowQuality

' Apply strong encryption to PDF documents
pdf.SecuritySettings.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256
pdf.SaveAs("secure-document.pdf")

using IronPdf;
using IronPdf.Signing;

var renderer = new ChromePdfRenderer();

// Generate PDF from HTML page
var pdf = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1>");

// Create digital signature with certificate for PDF files
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningContact = "legal@company.com",
    SigningLocation = "New York, NY",
    SigningReason = "Contract Approval"
};

// Apply signature to PDF documents
pdf.Sign(signature);
pdf.SaveAs("signed-contract.pdf");

Imports IronPdf
Imports IronPdf.Signing

Dim renderer As New ChromePdfRenderer()

' Generate PDF from HTML page
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1>")

' Create digital signature with certificate for PDF files
Dim signature As New PdfSignature("certificate.pfx", "password") With {
    .SigningContact = "legal@company.com",
    .SigningLocation = "New York, NY",
    .SigningReason = "Contract Approval"
}

' Apply signature to PDF documents
pdf.Sign(signature)
pdf.SaveAs("signed-contract.pdf")

using IronPdf;

var renderer = new ChromePdfRenderer();

// Enable HTML form to PDF form conversion
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

string htmlForm = @"
    <h2>Employee Onboarding Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' value='' /><br/>
        <label>Department:</label>
        <select name='department'>
            <option value='engineering'>Engineering</option>
            <option value='marketing'>Marketing</option>
            <option value='sales'>Sales</option>
        </select><br/>
        <label>Agree to Terms:</label>
        <input type='checkbox' name='agreeTerms' />
    </form>";

var pdf = renderer.RenderHtmlAsPdf(htmlForm);
pdf.SaveAs("onboarding-form.pdf");

Imports IronPdf

Dim renderer = New ChromePdfRenderer()

' Enable HTML form to PDF form conversion
renderer.RenderingOptions.CreatePdfFormsFromHtml = True

Dim htmlForm As String = "
    <h2>Employee Onboarding Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' value='' /><br/>
        <label>Department:</label>
        <select name='department'>
            <option value='engineering'>Engineering</option>
            <option value='marketing'>Marketing</option>
            <option value='sales'>Sales</option>
        </select><br/>
        <label>Agree to Terms:</label>
        <input type='checkbox' name='agreeTerms' />
    </form>"

Dim pdf = renderer.RenderHtmlAsPdf(htmlForm)
pdf.SaveAs("onboarding-form.pdf")

using IronPdf;

// Full page HTML containing the target element
string fullPageHtml = @"
<html>
<body>
    <header><h1>Acme Corp Invoice</h1></header>
    <div id='invoice-summary'>
        <h2>Invoice #12345</h2>
        <p>Total: $1,250.00</p>
    </div>
    <footer>Confidential</footer>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;

// Replace the body with only the target element
renderer.RenderingOptions.Javascript = @"
    var el = document.querySelector('#invoice-summary');
    if (el) {
        var head = document.head.innerHTML;
        document.body.innerHTML = el.outerHTML;
        document.head.innerHTML = head;
    }
";

// Wait for the target element before JS executes
renderer.RenderingOptions.WaitFor.HtmlQuerySelector("#invoice-summary", 10000);

var pdf = renderer.RenderHtmlAsPdf(fullPageHtml);
pdf.SaveAs("invoice-summary.pdf");

Imports IronPdf

' Full page HTML containing the target element
Dim fullPageHtml As String = "
<html>
<body>
    <header><h1>Acme Corp Invoice</h1></header>
    <div id='invoice-summary'>
        <h2>Invoice #12345</h2>
        <p>Total: $1,250.00</p>
    </div>
    <footer>Confidential</footer>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True

' Replace the body with only the target element
renderer.RenderingOptions.Javascript = "
    var el = document.querySelector('#invoice-summary');
    if (el) {
        var head = document.head.innerHTML;
        document.body.innerHTML = el.outerHTML;
        document.head.innerHTML = head;
    }
"

' Wait for the target element before JS executes
renderer.RenderingOptions.WaitFor.HtmlQuerySelector("#invoice-summary", 10000)

Dim pdf = renderer.RenderHtmlAsPdf(fullPageHtml)
pdf.SaveAs("invoice-summary.pdf")

using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure network authentication
renderer.LoginCredentials = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "securePassword",
    AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
};

var pdf = renderer.RenderUrlAsPdf("https://intranet.company.com/reports");
pdf.SaveAs("authenticated-report.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Configure network authentication
renderer.LoginCredentials = New ChromeHttpLoginCredentials With {
    .NetworkUsername = "user@domain.com",
    .NetworkPassword = "securePassword",
    .AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
}

Dim pdf = renderer.RenderUrlAsPdf("https://intranet.company.com/reports")
pdf.SaveAs("authenticated-report.pdf")

using IronPdf;

var renderer = new ChromePdfRenderer();

// Add session cookies
renderer.RenderingOptions.CustomCookies["sessionId"] = "abc123token";
renderer.RenderingOptions.CustomCookies["authToken"] = "bearer-xyz";

// Add custom HTTP headers (e.g., API key or Bearer token)
renderer.RenderingOptions.HttpRequestHeaders["Authorization"] = "Bearer eyJhbGciOi...";

var pdf = renderer.RenderUrlAsPdf("https://app.example.com/dashboard");
pdf.SaveAs("dashboard.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Add session cookies
renderer.RenderingOptions.CustomCookies("sessionId") = "abc123token"
renderer.RenderingOptions.CustomCookies("authToken") = "bearer-xyz"

' Add custom HTTP headers (e.g., API key or Bearer token)
renderer.RenderingOptions.HttpRequestHeaders("Authorization") = "Bearer eyJhbGciOi..."

Dim pdf = renderer.RenderUrlAsPdf("https://app.example.com/dashboard")
pdf.SaveAs("dashboard.pdf")

using IronPdf;

// Azure sandboxes block GPU access, always disable
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
// Required on non-GUI Linux systems
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = true;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Azure PDF Report</h1>");
pdf.SaveAs("azure-report.pdf");

Imports IronPdf

' Azure sandboxes block GPU access, always disable
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled
' Required on non-GUI Linux systems
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = True

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Azure PDF Report</h1>")
pdf.SaveAs("azure-report.pdf")

using Amazon.Lambda.Core;
using IronPdf;

public class PdfFunction
{
    public string FunctionHandler(string input, ILambdaContext context)
    {
        // Lambda's only writable directory
        var tmpPath = "/tmp/";

        IronPdf.Installation.TempFolderPath = tmpPath;
        IronPdf.Installation.CustomDeploymentDirectory = tmpPath;
        IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
        // Let IronPDF install Chrome dependencies on first cold start
        IronPdf.Installation.LinuxAndDockerDependenciesOtomatik Konfigürasyon = true;

        context.Logger.LogLine("Rendering PDF...");

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(input);

        // Save to /tmp before uploading to S3 or returning
        var outputPath = $"{tmpPath}output.pdf";
        pdf.SaveAs(outputPath);

        return outputPath;
    }
}

Imports Amazon.Lambda.Core
Imports IronPdf

Public Class PdfFunction
    Public Function FunctionHandler(input As String, context As ILambdaContext) As String
        ' Lambda's only writable directory
        Dim tmpPath As String = "/tmp/"

        IronPdf.Installation.TempFolderPath = tmpPath
        IronPdf.Installation.CustomDeploymentDirectory = tmpPath
        IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled
        ' Let IronPDF install Chrome dependencies on first cold start
        IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = True

        context.Logger.LogLine("Rendering PDF...")

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(input)

        ' Save to /tmp before uploading to S3 or returning
        Dim outputPath As String = $"{tmpPath}output.pdf"
        pdf.SaveAs(outputPath)

        Return outputPath
    End Function
End Class

using IronPdf;

// Dependencies handled by Dockerfile apt-get, disable runtime install
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = false;
// No GPU in containers
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Dockerized PDF</h1>");
pdf.SaveAs("output.pdf");

Imports IronPdf

' Dependencies handled by Dockerfile apt-get, disable runtime install
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = False
' No GPU in containers
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Dockerized PDF</h1>")
pdf.SaveAs("output.pdf")