Incrustar imágenes con DataURI en C# y VB: renderizado de PDF

Ejemplo básico de incrustación de imágenes

Este ejemplo completo muestra cómo incrustar una imagen en un PDF utilizando DataURIs:

:path=/static-assets/pdf/content-code-examples/how-to/datauris-image.cs

using IronPdf;
using System;

// Read byte from image file
var pngBinaryData = System.IO.File.ReadAllBytes("My_image.png");

// Convert bytes to base64
var ImgDataURI = @"data:image/png;base64," + Convert.ToBase64String(pngBinaryData);

// Import base64 to img tag
var ImgHtml = $"<img src='{ImgDataURI}'>";

ChromePdfRenderer Renderer = new ChromePdfRenderer();

// Render the HTML string
var pdf = Renderer.RenderHtmlAsPdf(ImgHtml);

pdf.SaveAs("datauri_example.pdf");

Imports IronPdf
Imports System

' Read byte from image file
Private pngBinaryData = System.IO.File.ReadAllBytes("My_image.png")

' Convert bytes to base64
Private ImgDataURI = "data:image/png;base64," & Convert.ToBase64String(pngBinaryData)

' Import base64 to img tag
Private ImgHtml = $"<img src='{ImgDataURI}'>"

Private Renderer As New ChromePdfRenderer()

' Render the HTML string
Private pdf = Renderer.RenderHtmlAsPdf(ImgHtml)

pdf.SaveAs("datauri_example.pdf")

Los desarrolladores de VB.NET pueden conseguir la misma funcionalidad utilizando la biblioteca VB.NET PDF de IronPDF:

Imports IronPdf
Imports System

' Read byte from image file
Dim pngBinaryData As Byte() = System.IO.File.ReadAllBytes("My_image.png")

' Convert bytes to base64
Dim ImgDataURI As String = "data:image/png;base64," & Convert.ToBase64String(pngBinaryData)

' Import base64 to img tag
Dim ImgHtml As String = $"<img src='{ImgDataURI}'>"

Dim Renderer As New ChromePdfRenderer()

' Render the HTML string
Dim pdf = Renderer.RenderHtmlAsPdf(ImgHtml)

pdf.SaveAs("datauri_example.pdf")

¿Por qué debería usar DataURIs en lugar de referencias a archivos?

DataURIs ofrece varias ventajas sobre las referencias de archivos tradicionales al generar PDFs. En primer lugar, eliminan las dependencias de archivos externos, lo que hace que la generación de PDF sea más fiable y portátil. Esto es crucial en entornos de nube como Azure o AWS Lambda, donde el acceso al sistema de archivos puede ser limitado o sensible al rendimiento.

En segundo lugar, DataURIs asegura que los PDFs sean completamente autónomos. A la hora de compartir o distribuir los PDF generados, los enlaces de imágenes rotos o la falta de recursos no son una preocupación. Esto hace a DataURIs ideal para generar informes, facturas o documentos que requieren archivo o distribución por correo electrónico.

En tercer lugar, DataURIs puede mejorar el rendimiento en ciertos escenarios. Dado que los datos de imagen se incrustan directamente en HTML, no se producen peticiones HTTP adicionales ni operaciones del sistema de archivos durante la renderización. De este modo, se agiliza la generación de PDF, especialmente cuando se manejan varias imágenes pequeñas.

¿Qué formatos de imagen se admiten?

IronPDF admite todos los formatos de imagen principales a través de DataURIs, proporcionando flexibilidad en los flujos de trabajo de generación de PDF:

• PNG: Ideal para imágenes con transparencia o gráficos con bordes afilados. Utiliza data:image/png;base64,
• JPEG: mejor para fotografías e imágenes complejas con muchos colores. Utiliza data:image/jpeg;base64,
• GIF: Adecuado para animaciones sencillas o imágenes con colores limitados. Utiliza data:image/gif;base64,
• SVG: Perfecto para gráficos vectoriales escalables. Utiliza data:image/svg+xml;base64,
• WebP: Formato moderno con excelente compresión. Utiliza data:image/webp;base64,

El siguiente ejemplo muestra cómo manejar diferentes formatos de imagen:

using IronPdf;
using System;
using System.IO;

public class MultiFormatImageEmbedding
{
    public static void EmbedVariousImageFormats()
    {
        var renderer = new ChromePdfRenderer();

        // Function to create DataURI from image file
        string CreateDataUri(string filePath, string mimeType)
        {
            var imageBytes = File.ReadAllBytes(filePath);
            return $"data:{mimeType};base64,{Convert.ToBase64String(imageBytes)}";
        }

        // Create HTML with multiple image formats
        var html = $@"
        <html>
        <body>
            <h1>Multi-Format Image Test</h1>
            <img src='{CreateDataUri("logo.png", "image/png")}' alt='PNG Logo' />
            <img src='{CreateDataUri("photo.jpg", "image/jpeg")}' alt='JPEG Photo' />
            <img src='{CreateDataUri("icon.svg", "image/svg+xml")}' alt='SVG Icon' />
        </body>
        </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("multi_format_images.pdf");
    }
}

using IronPdf;
using System;
using System.IO;

public class MultiFormatImageEmbedding
{
    public static void EmbedVariousImageFormats()
    {
        var renderer = new ChromePdfRenderer();

        // Function to create DataURI from image file
        string CreateDataUri(string filePath, string mimeType)
        {
            var imageBytes = File.ReadAllBytes(filePath);
            return $"data:{mimeType};base64,{Convert.ToBase64String(imageBytes)}";
        }

        // Create HTML with multiple image formats
        var html = $@"
        <html>
        <body>
            <h1>Multi-Format Image Test</h1>
            <img src='{CreateDataUri("logo.png", "image/png")}' alt='PNG Logo' />
            <img src='{CreateDataUri("photo.jpg", "image/jpeg")}' alt='JPEG Photo' />
            <img src='{CreateDataUri("icon.svg", "image/svg+xml")}' alt='SVG Icon' />
        </body>
        </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("multi_format_images.pdf");
    }
}

Imports IronPdf
Imports System
Imports System.IO

Public Class MultiFormatImageEmbedding
    Public Shared Sub EmbedVariousImageFormats()
        Dim renderer As New ChromePdfRenderer()

        ' Function to create DataURI from image file
        Function CreateDataUri(filePath As String, mimeType As String) As String
            Dim imageBytes = File.ReadAllBytes(filePath)
            Return $"data:{mimeType};base64,{Convert.ToBase64String(imageBytes)}"
        End Function

        ' Create HTML with multiple image formats
        Dim html = $"
        <html>
        <body>
            <h1>Multi-Format Image Test</h1>
            <img src='{CreateDataUri("logo.png", "image/png")}' alt='PNG Logo' />
            <img src='{CreateDataUri("photo.jpg", "image/jpeg")}' alt='JPEG Photo' />
            <img src='{CreateDataUri("icon.svg", "image/svg+xml")}' alt='SVG Icon' />
        </body>
        </html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("multi_format_images.pdf")
    End Sub
End Class

Para el manejo avanzado de imágenes, incluyendo añadir imágenes a PDFs existentes, IronPDF proporciona un soporte completo.

¿Cómo afecta la codificación Base64 al tamaño de los archivos?

La codificación Base64 aumenta el tamaño de los datos en aproximadamente un 33%. Base64 representa datos binarios utilizando sólo 64 caracteres ASCII, lo que requiere 4 caracteres para representar cada 3 bytes de datos originales. Aunque esto aumenta el tamaño total, el impacto en la generación de PDF suele ser mínimo en comparación con las ventajas de los documentos autocontenidos.

Optimiza los tamaños de archivo al usar DataURIs siguiendo estas prácticas:

1. Comprimir imágenes antes de codificar: Usa herramientas o bibliotecas para optimizar archivos de imagen antes de convertirlos a base64
2. Elegir formatos apropiados: Usa JPEG para fotos, PNG para gráficos con transparencia
3. Redimensionar adecuadamente las imágenes: No incrustar imágenes más grandes de lo necesario para la salida PDF
4. Considere la compresión de PDF: Utilice las funciones de compresión de IronPDF después de la generación

Este ejemplo muestra la optimización de imágenes antes de incrustarlas:

using IronPdf;
using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

public class OptimizedImageEmbedding
{
    public static void EmbedOptimizedImage(string imagePath, int maxWidth = 800)
    {
        // Load and resize image if necessary
        using (var originalImage = Image.FromFile(imagePath))
        {
            var resizedImage = originalImage;

            if (originalImage.Width > maxWidth)
            {
                var ratio = (double)maxWidth / originalImage.Width;
                var newHeight = (int)(originalImage.Height * ratio);
                resizedImage = new Bitmap(originalImage, maxWidth, newHeight);
            }

            // Convert to optimized JPEG
            using (var ms = new MemoryStream())
            {
                var encoder = ImageCodecInfo.GetImageEncoders()
                    .First(c => c.FormatID == ImageFormat.Jpeg.Guid);
                var encoderParams = new EncoderParameters(1);
                encoderParams.Param[0] = new EncoderParameter(
                    System.Drawing.Imaging.Encoder.Quality, 85L);

                resizedImage.Save(ms, encoder, encoderParams);
                var imageBytes = ms.ToArray();

                // Create DataURI
                var dataUri = $"data:image/jpeg;base64,{Convert.ToBase64String(imageBytes)}";

                // Generate PDF
                var html = $@"
                <html>
                <body>
                    <h1>Optimized Image Example</h1>
                    <img src='{dataUri}' style='max-width: 100%;' />
                </body>
                </html>";

                var renderer = new ChromePdfRenderer();
                var pdf = renderer.RenderHtmlAsPdf(html);
                pdf.SaveAs("optimized_image.pdf");
            }

            if (resizedImage != originalImage)
                resizedImage.Dispose();
        }
    }
}

using IronPdf;
using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

public class OptimizedImageEmbedding
{
    public static void EmbedOptimizedImage(string imagePath, int maxWidth = 800)
    {
        // Load and resize image if necessary
        using (var originalImage = Image.FromFile(imagePath))
        {
            var resizedImage = originalImage;

            if (originalImage.Width > maxWidth)
            {
                var ratio = (double)maxWidth / originalImage.Width;
                var newHeight = (int)(originalImage.Height * ratio);
                resizedImage = new Bitmap(originalImage, maxWidth, newHeight);
            }

            // Convert to optimized JPEG
            using (var ms = new MemoryStream())
            {
                var encoder = ImageCodecInfo.GetImageEncoders()
                    .First(c => c.FormatID == ImageFormat.Jpeg.Guid);
                var encoderParams = new EncoderParameters(1);
                encoderParams.Param[0] = new EncoderParameter(
                    System.Drawing.Imaging.Encoder.Quality, 85L);

                resizedImage.Save(ms, encoder, encoderParams);
                var imageBytes = ms.ToArray();

                // Create DataURI
                var dataUri = $"data:image/jpeg;base64,{Convert.ToBase64String(imageBytes)}";

                // Generate PDF
                var html = $@"
                <html>
                <body>
                    <h1>Optimized Image Example</h1>
                    <img src='{dataUri}' style='max-width: 100%;' />
                </body>
                </html>";

                var renderer = new ChromePdfRenderer();
                var pdf = renderer.RenderHtmlAsPdf(html);
                pdf.SaveAs("optimized_image.pdf");
            }

            if (resizedImage != originalImage)
                resizedImage.Dispose();
        }
    }
}

Imports IronPdf
Imports System
Imports System.Drawing
Imports System.Drawing.Imaging
Imports System.IO

Public Class OptimizedImageEmbedding
    Public Shared Sub EmbedOptimizedImage(imagePath As String, Optional maxWidth As Integer = 800)
        ' Load and resize image if necessary
        Using originalImage As Image = Image.FromFile(imagePath)
            Dim resizedImage As Image = originalImage

            If originalImage.Width > maxWidth Then
                Dim ratio As Double = CDbl(maxWidth) / originalImage.Width
                Dim newHeight As Integer = CInt(originalImage.Height * ratio)
                resizedImage = New Bitmap(originalImage, maxWidth, newHeight)
            End If

            ' Convert to optimized JPEG
            Using ms As New MemoryStream()
                Dim encoder As ImageCodecInfo = ImageCodecInfo.GetImageEncoders().First(Function(c) c.FormatID = ImageFormat.Jpeg.Guid)
                Dim encoderParams As New EncoderParameters(1)
                encoderParams.Param(0) = New EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 85L)

                resizedImage.Save(ms, encoder, encoderParams)
                Dim imageBytes As Byte() = ms.ToArray()

                ' Create DataURI
                Dim dataUri As String = $"data:image/jpeg;base64,{Convert.ToBase64String(imageBytes)}"

                ' Generate PDF
                Dim html As String = $"
                <html>
                <body>
                    <h1>Optimized Image Example</h1>
                    <img src='{dataUri}' style='max-width: 100%;' />
                </body>
                </html>"

                Dim renderer As New ChromePdfRenderer()
                Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
                pdf.SaveAs("optimized_image.pdf")
            End Using

            If resizedImage IsNot originalImage Then
                resizedImage.Dispose()
            End If
        End Using
    End Sub
End Class

VeriFactu y el archivo PDF autocontenido en la AEAT

El sistema VeriFactu, regulado por la AEAT para el control en tiempo real de la facturación, genera facturas que deben poder visualizarse y verificarse de forma íntegra desde el portal de la Agencia Tributaria durante cuatro años. Para garantizar que los PDFs de factura sean legibles independientemente del servidor donde se almacenen, todos los recursos visuales —logotipos corporativos, código QR con la URL de verificación de la AEAT, pie de firma electrónica y cualquier imagen incluida en la cabecera— deben incrustarse como DataURIs en Base64. De este modo, el PDF es completamente autocontenido y puede abrirse en cualquier entorno sin dependencias externas, cumpliendo los requisitos de integridad del archivo VeriFactu.

Facturae, FACe y la incrustación de recursos para PDF/A

Las facturas electrónicas enviadas a administraciones públicas a través del portal FACe deben adjuntarse en formato PDF/A, que por definición requiere que todos los recursos sean autocontenidos: fuentes incrustadas, imágenes en Base64 y sin referencias externas. Al utilizar DataURIs con IronPDF para los logotipos y elementos visuales de la factura Facturae, se garantiza la conformidad con el estándar PDF/A y se evitan los rechazos por recursos no disponibles durante la validación en FACe. Además, la correcta incrustación mediante UTF-8 es imprescindible para que los nombres de empresa con caracteres especiales del español (ñ, vocales acentuadas) se representen correctamente en los archivos de la AEAT.

Adoptar la técnica DataURI en los flujos de generación de facturas con IronPDF es una decisión de arquitectura que simplifica el cumplimiento de los requisitos de archivo exigidos por VeriFactu y FACe, reduciendo el riesgo de documentos incompletos o ilegibles en las inspecciones fiscales de la Agencia Tributaria.

Utiliza la directiva using IronPdf para incluir el espacio de nombres IronPdf en tus proyectos de C# o VB.NET.

El método AddBookmarkAtEnd se utiliza para agregar nuevos marcadores al esquema del PDF.