How to Convert PDF to Image in .NET?

var pdf = PdfDocument.FromFile("invoice.pdf");
pdf.RasterizeToImageFiles(@"C:\images\folder\page_*.png");

Dim pdf = PdfDocument.FromFile("invoice.pdf")
pdf.RasterizeToImageFiles("C:\images\folder\page_*.png")

// Async conversion for better performance in containerized environments
public async Task ConvertPdfToImagesAsync(string inputPath, string outputPattern)
{
    var pdf = await PdfDocument.FromFileAsync(inputPath);
    await pdf.RasterizeToImageFilesAsync(outputPattern);
}

' Async conversion for better performance in containerized environments
Public Async Function ConvertPdfToImagesAsync(inputPath As String, outputPattern As String) As Task
    Dim pdf = Await PdfDocument.FromFileAsync(inputPath)
    Await pdf.RasterizeToImageFilesAsync(outputPattern)
End Function

// Event handler example for Windows Forms application
private void ConvertButton_Click(object sender, EventArgs e)
{
    var pdf = PdfDocument.FromFile("report.pdf");
    var pageRange = Enumerable.Range(0, 5); // First 5 pages
    pdf.RasterizeToImageFiles(
        @"C:\output\page_*.jpg",
        pageRange,
        1920,   // Width in pixels
        1080,   // Height in pixels
        IronPdf.Imaging.ImageType.Jpeg,
        150     // Image DPI setting
    );
}

' Event handler example for Windows Forms application
Private Sub ConvertButton_Click(sender As Object, e As EventArgs)
    Dim pdf = PdfDocument.FromFile("report.pdf")
    Dim pageRange = Enumerable.Range(0, 5) ' First 5 pages
    pdf.RasterizeToImageFiles(
        "C:\output\page_*.jpg",
        pageRange,
        1920,   ' Width in pixels
        1080,   ' Height in pixels
        IronPdf.Imaging.ImageType.Jpeg,
        150     ' Image DPI setting
    )
End Sub

// Health check endpoint for Kubernetes readiness probe
[HttpGet("/health/pdf-converter")]
public IActionResult HealthCheck()
{
    try
    {
        // Test basic PDF functionality
        var testPdf = new PdfDocument("<p>Health Check</p>");
        var imageBytes = testPdf.RasterizeToImageFiles(ImageType.Png);
        return Ok(new { status = "healthy", timestamp = DateTime.UtcNow });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { status = "unhealthy", error = ex.Message });
    }
}

' Health check endpoint for Kubernetes readiness probe
<HttpGet("/health/pdf-converter")>
Public Function HealthCheck() As IActionResult
    Try
        ' Test basic PDF functionality
        Dim testPdf As New PdfDocument("<p>Health Check</p>")
        Dim imageBytes = testPdf.RasterizeToImageFiles(ImageType.Png)
        Return Ok(New With {Key .status = "healthy", Key .timestamp = DateTime.UtcNow})
    Catch ex As Exception
        Return StatusCode(503, New With {Key .status = "unhealthy", Key .error = ex.Message})
    End Try
End Function

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_52___");
pdf.RasterizeToImageFiles(@"C:\web\screenshot_*.png");

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_52___")
pdf.RasterizeToImageFiles("C:\web\screenshot_*.png")

// Configure renderer for reliable containerized deployment
var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        RenderDelay = 2000, // Wait 2 seconds for dynamic content
        Timeout = 30000,    // 30-second timeout for slow networks
        EnableJavaScript = true,
        ViewPortWidth = 1920,
        ViewPortHeight = 1080
    }
};

// Add custom HTTP headers for authentication if needed
renderer.RenderingOptions.CustomCssUrl = "___PROTECTED_URL_53___";

' Configure renderer for reliable containerized deployment
Dim renderer = New ChromePdfRenderer With {
    .RenderingOptions = New ChromePdfRenderOptions With {
        .RenderDelay = 2000, ' Wait 2 seconds for dynamic content
        .Timeout = 30000,    ' 30-second timeout for slow networks
        .EnableJavaScript = True,
        .ViewPortWidth = 1920,
        .ViewPortHeight = 1080
    }
}

' Add custom HTTP headers for authentication if needed
renderer.RenderingOptions.CustomCssUrl = "___PROTECTED_URL_53___"

// Improve JPEG conversion for web deployment
public void ConvertToOptimizedJpeg(string pdfPath, int quality = 85)
{
    var pdf = PdfDocument.FromFile(pdfPath);

    // Configure JPEG-specific settings
    var jpegEncoder = new JpegEncoder { Quality = quality };

    pdf.RasterizeToImageFiles(
        @"optimized_*.jpg",
        imageType: ImageType.Jpeg,
        dpi: 96  // Web-improve DPI
    );
}

' Improve JPEG conversion for web deployment
Public Sub ConvertToOptimizedJpeg(pdfPath As String, Optional quality As Integer = 85)
    Dim pdf = PdfDocument.FromFile(pdfPath)

    ' Configure JPEG-specific settings
    Dim jpegEncoder As New JpegEncoder With {.Quality = quality}

    pdf.RasterizeToImageFiles(
        "optimized_*.jpg",
        imageType:=ImageType.Jpeg,
        dpi:=96  ' Web-improve DPI
    )
End Sub

// Convert PDF to multi-page TIFF - all pages in single file
var pdf = PdfDocument.FromFile("multipage.pdf");
pdf.ToMultiPageTiffImage(@"C:\archive\document.tiff", null, null, 300);
// Process complete - single TIFF contains all pages
Console.WriteLine("PDF converted to multi-page TIFF");

' Convert PDF to multi-page TIFF - all pages in single file
Dim pdf = PdfDocument.FromFile("multipage.pdf")
pdf.ToMultiPageTiffImage("C:\archive\document.tiff", Nothing, Nothing, 300)
' Process complete - single TIFF contains all pages
Console.WriteLine("PDF converted to multi-page TIFF")

// Docker-improve conversion with memory management
public class PdfImageConverter : IDisposable
{
    private readonly ChromePdfRenderer _renderer;

    public PdfImageConverter()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                // Improve for container memory limits
                CreatePdfFormsFromHtml = false,
                EnableJavaScript = false,
                RenderDelay = 0
            }
        };
    }

    public async Task<byte[]> ConvertToImageBytesAsync(string pdfPath, int pageIndex = 0)
    {
        using var pdf = await PdfDocument.FromFileAsync(pdfPath);
        var images = await pdf.RasterizeToBitmapsAsync(new[] { pageIndex }, 150);

        using var ms = new MemoryStream();
        images[0].Save(ms, ImageFormat.Png);
        return ms.ToArray();
    }

    public void Dispose()
    {
        _renderer?.Dispose();
    }
}

Imports System
Imports System.IO
Imports System.Drawing.Imaging
Imports System.Threading.Tasks

Public Class PdfImageConverter
    Implements IDisposable

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer With {
            .RenderingOptions = New ChromePdfRenderOptions With {
                .CreatePdfFormsFromHtml = False,
                .EnableJavaScript = False,
                .RenderDelay = 0
            }
        }
    End Sub

    Public Async Function ConvertToImageBytesAsync(pdfPath As String, Optional pageIndex As Integer = 0) As Task(Of Byte())
        Using pdf = Await PdfDocument.FromFileAsync(pdfPath)
            Dim images = Await pdf.RasterizeToBitmapsAsync(New Integer() {pageIndex}, 150)

            Using ms As New MemoryStream()
                images(0).Save(ms, ImageFormat.Png)
                Return ms.ToArray()
            End Using
        End Using
    End Function

    Public Sub Dispose() Implements IDisposable.Dispose
        _renderer?.Dispose()
    End Sub
End Class

// Production-ready batch conversion service
public class BatchImageConversionService
{
    private readonly ILogger<BatchImageConversionService> _logger;
    private readonly SemaphoreSlim _semaphore;

    public BatchImageConversionService(ILogger<BatchImageConversionService> logger)
    {
        _logger = logger;
        _semaphore = new SemaphoreSlim(Environment.ProcessorCount);
    }

    public async Task<ConversionResult> ConvertBatchAsync(
        IEnumerable<string> pdfPaths, 
        ConversionOptions options)
    {
        var tasks = pdfPaths.Select(path => ConvertWithThrottlingAsync(path, options));
        var results = await Task.WhenAll(tasks);

        return new ConversionResult
        {
            TotalFiles = results.Length,
            SuccessCount = results.Count(r => r.Success),
            FailedFiles = results.Where(r => !r.Success).Select(r => r.FilePath)
        };
    }

    private async Task<FileConversionResult> ConvertWithThrottlingAsync(
        string pdfPath, 
        ConversionOptions options)
    {
        await _semaphore.WaitAsync();
        try
        {
            var stopwatch = Stopwatch.StartNew();
            var pdf = await PdfDocument.FromFileAsync(pdfPath);

            await pdf.RasterizeToImageFilesAsync(
                Path.Combine(options.OutputDirectory, $"{Path.GetFileNameWithoutExtension(pdfPath)}_*.{options.Format}"),
                imageType: options.Format,
                dpi: options.Dpi
            );

            _logger.LogInformation(
                "Converted {FileName} in {ElapsedMs}ms", 
                Path.GetFileName(pdfPath), 
                stopwatch.ElapsedMilliseconds
            );

            return new FileConversionResult { Success = true, FilePath = pdfPath };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to convert {FileName}", Path.GetFileName(pdfPath));
            return new FileConversionResult { Success = false, FilePath = pdfPath, Error = ex.Message };
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

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

Public Class BatchImageConversionService
    Private ReadOnly _logger As ILogger(Of BatchImageConversionService)
    Private ReadOnly _semaphore As SemaphoreSlim

    Public Sub New(logger As ILogger(Of BatchImageConversionService))
        _logger = logger
        _semaphore = New SemaphoreSlim(Environment.ProcessorCount)
    End Sub

    Public Async Function ConvertBatchAsync(pdfPaths As IEnumerable(Of String), options As ConversionOptions) As Task(Of ConversionResult)
        Dim tasks = pdfPaths.Select(Function(path) ConvertWithThrottlingAsync(path, options))
        Dim results = Await Task.WhenAll(tasks)

        Return New ConversionResult With {
            .TotalFiles = results.Length,
            .SuccessCount = results.Count(Function(r) r.Success),
            .FailedFiles = results.Where(Function(r) Not r.Success).Select(Function(r) r.FilePath)
        }
    End Function

    Private Async Function ConvertWithThrottlingAsync(pdfPath As String, options As ConversionOptions) As Task(Of FileConversionResult)
        Await _semaphore.WaitAsync()
        Try
            Dim stopwatch = Stopwatch.StartNew()
            Dim pdf = Await PdfDocument.FromFileAsync(pdfPath)

            Await pdf.RasterizeToImageFilesAsync(
                Path.Combine(options.OutputDirectory, $"{Path.GetFileNameWithoutExtension(pdfPath)}_*.{options.Format}"),
                imageType:=options.Format,
                dpi:=options.Dpi
            )

            _logger.LogInformation(
                "Converted {FileName} in {ElapsedMs}ms",
                Path.GetFileName(pdfPath),
                stopwatch.ElapsedMilliseconds
            )

            Return New FileConversionResult With {.Success = True, .FilePath = pdfPath}
        Catch ex As Exception
            _logger.LogError(ex, "Failed to convert {FileName}", Path.GetFileName(pdfPath))
            Return New FileConversionResult With {.Success = False, .FilePath = pdfPath, .Error = ex.Message}
        Finally
            _semaphore.Release()
        End Try
    End Function
End Class