Cree documentos PDF en C# y VB.NET

¿Usted, como desarrollador de .NET, necesita generar informes, facturas, recibos u otros documentos en PDF? Utilice la biblioteca Docotic.Pdf para generar documentos PDF en sus proyectos .NET Core, .NET Standard o .NET Framework. Puedes hacer esto fácilmente y sin tener ningún conocimiento sobre el formato PDF.

API .NET para generación de PDF

Docotic.Pdf es la biblioteca de código 100% administrada sin dependencias externas. Puede usarlo para crear documentos PDF en entornos de nube Windows, Linux, Amazon y Azure. macOS, iOS, Android y otros entornos en la nube también están bien.

La biblioteca ofrece diferentes formas de generar documentos PDF. En primer lugar, puede utilizar la API de diseño de alto nivel para agregar encabezados y pies de página, tablas, párrafos y dividir automáticamente el contenido en las páginas. La API de diseño está disponible en el complemento gratuito Docotic.Pdf.Layout.

O puede crear documentos PDF basados en plantillas HTML usando el complemento HTML a PDF (también gratis). Lea el artículo Convertir HTML a PDF para obtener más detalles.

Y puede producir documentos PDF utilizando la API de la biblioteca principal. Admite cualquier contenido PDF: texto, imágenes, gráficos vectoriales, formularios, anotaciones, marcadores, capas y otros. Sin embargo, la API principal no admite componentes de diseño de alto nivel, como encabezados, tablas y secciones. Con la biblioteca principal, usted mismo deberá medir el contenido y dividirlo entre páginas PDF.

También puede utilizar complementos con la biblioteca principal juntos. Por ejemplo, genere el documento PDF utilizando la API de diseño y luego agregue más contenido con la biblioteca principal. Tenga en cuenta que el complemento de diseño es compatible con .NET Standard 2.1, .NET Core, .NET 5 y marcos más nuevos. La biblioteca principal y el complemento de HTML a PDF son compatibles con .NET Standard 2.0, .NET 4.7.2+, .NET Core, .NET 5 y posteriores.

Los complementos de Docotic.Pdf están disponibles en NuGet y se incluyen en el zip con binarios de la biblioteca. Para probar la biblioteca sin restricciones del modo de evaluación, puede obtener la clave de licencia gratuita por tiempo limitado aquí.

Cree documentos PDF utilizando la API de diseño

Este ejemplo de C# muestra cómo generar un documento PDF en C# usando la API de diseño:

PdfDocumentBuilder
    .Create()
    .Generate("long-text.pdf", doc => doc.Pages(page =>
    {
        string text = File.ReadAllText(@"C# in Depth, Fourth Edition.txt");
        page.Content().Text(text);

        page.Footer().AlignCenter().Text(t => t.CurrentPageNumber());
    }));

El código convierte un archivo de texto a PDF. Divide el texto extenso en páginas y también dibuja los números de página en el área del pie de página. No es necesario calcular la altura del texto ni contar páginas: la biblioteca se encarga de estas tareas rutinarias.

La API de diseño es una API fluida. La mayoría de las llamadas se pueden encadenar, por lo que puedes escribir código más compacto que con marcos "declarativos". Repasemos la API con más detalle.

Establecer propiedades del documento PDF

La generación de PDF comienza con la clase PdfDocumentBuilder. Le permite especificar propiedades de un documento PDF generado. Por ejemplo, puede configurar metadatos, cifrado, versión PDF o habilitar la vista web rápida. Aquí está el ejemplo básico de C#:

PdfDocumentBuilder
    .Create()
    .Encryption(new PdfStandardEncryptionHandler("owner", "user"))
    .Info(info =>
    {
        info.Author = "Docotic.Pdf library";
        info.Title = "How to create PDF in .NET";
        info.Keywords = "C#, VB.NET";
    })
    .Version(PdfVersion.Pdf16)
    .Generate("result.pdf", doc => doc.Pages(_ => {}));

Este ejemplo crea un documento PDF vacío protegido con contraseña con metadatos personalizados y lo guarda en un archivo. También puede guardar el documento en una secuencia, simplemente use la sobrecarga de PdfDocumentBuilder.Generate(Stream, ..).

Cuando configura un PdfDocumentBuilder, es hora de completar el documento PDF con contenido. La API de diseño proporciona un objeto Document para registrar recursos comunes (tipografía, imágenes) y definir el contenido de la página PDF. Puede configurar un Document en el segundo argumento de los métodos PdfDocumentBuilder.Generate. Aprendamos a configurar páginas PDF.

Definir el diseño de la página PDF

Este ejemplo de C# muestra cómo crear un documento PDF con páginas A3 en orientación horizontal:

PdfDocumentBuilder.Create().Generate("pages.pdf", doc =>
{
    doc.Pages((PageLayout page) =>
    {
        page.Size(PdfPaperSize.A3, PdfPaperOrientation.Landscape)
            .MarginVertical(50)
            .MarginHorizontal(40);

        page.Header().PaddingBottom(30).AlignRight().Text("Hello PDF");

        page.Content().Column(c =>
        {
            c.Item().Text("Page 1");
            c.Item().PageBreak();
            c.Item().Text("Page 2");
        });

        page.Footer().Text(t => t.CurrentPageNumber());
    });
});

El método Document.Pages() define el diseño de una o más páginas. Primero, el código de muestra establece configuraciones comunes para todas las páginas: tamaño, orientación, márgenes. También puede especificar la dirección del contenido, el estilo de texto predeterminado o el color de fondo.

Luego, la muestra genera el diseño y el contenido de la página. La clase PageLayout proporciona métodos para colocar el contenido de la página en las siguientes ranuras:

• Background() - una capa de fondo cubierta por otro contenido
• Header() - un encabezado común para todas las páginas
• Content() - contenido de la página principal
• Footer() - un pie de página común para todas las páginas
• Foreground() - una capa de primer plano que cubre otro contenido

El motor de diseño genera páginas dependiendo del contenido agregado a la ranura PageLayout.Content(). Otros espacios se repiten en cada página. Puede agregar contenido a las ranuras usando la clase LayoutContainer. Este es un componente clave de la API de diseño, que le permite generar diseños, tablas, texto o imágenes arbitrarios.

El ejemplo anterior utiliza el método LayoutContainer.Column que apila contenido verticalmente. Esa columna contiene 3 elementos: el fragmento de texto de la primera página, el salto de página explícito y el fragmento de texto de la segunda página.

También existe el método LayoutContainer.Row. Mire cómo crear documentos PDF de varias columnas usando filas y columnas juntas.

Puede mezclar diferentes diseños de página en un documento PDF. Simplemente llame al método Document.Pages varias veces. Mire el ejemplo Configuración de diseño de página PDF en GitHub para ver un ejemplo.

Agregar texto a documentos PDF

El texto es una parte importante de los documentos PDF. Puede utilizar métodos LayoutContainer.Text para agregar texto. Anteriormente, viste casos de uso para la sobrecarga LayoutContainer.Text(string). Veamos otra sobrecarga de este método:

PdfDocumentBuilder.Create().Generate("text.pdf", doc =>
{
    doc.Pages(p => p.Content().Text(text =>
    {
        text.Span("VB.NET").Style(t => t.Strong);
        text.Span(" is a multi-paradigm, object-oriented programming language, implemented on.NET, Mono, and the ");
        text.Hyperlink(".NET Framework", new Uri("https://dotnet.microsoft.com/en-us/download/dotnet-framework"));
        text.Line(".");

        text.Line("Microsoft launched VB.NET in 2002 as the successor to its original Visual Basic language.");
    }));
});

La clase TextContainer proporciona métodos para dibujar texto, enlaces y números de página. Utilice los métodos Span y Line para agregar texto a una línea actual. El método Line además completa la línea actual. Este ejemplo también utiliza el método Hyperlink que agrega un enlace de recurso externo.

Aquí hay otro ejemplo que muestra cómo usar números de página dinámicos en un pie de página:

PdfDocumentBuilder.Create().Generate("footer.pdf", doc =>
{
    doc.Pages(p => p.Footer().AlignRight().Text(text =>
    {
        text.Style(t => t.Parent.FontColor(new PdfRgbColor(255, 0, 0)));

        text.CurrentPageNumber();
        text.Span(" / ");
        text.PageCount();
    }));
});

La API de diseño proporciona una forma de formatear los números de página. Por ejemplo, puedes dibujar números de página hexadecimales así:

text.CurrentPageNumber().Format(p => "0x" + p?.ToString("x2"));

El ejemplo Agregar encabezado y pie de página a documentos PDF en C# y VB.NET muestra cómo formatear los números de página como números romanos.

Es posible que vea que los ejemplos anteriores utilizan el método Style. Investiguemos el concepto de estilos de texto con más detalle.

Tipografía

Los estilos de texto le permiten personalizar la apariencia del texto. La clase TextStyle proporciona métodos para cambiar el tamaño de fuente, el espaciado entre letras, los colores y otras propiedades del texto. Los objetos TextStyle son inmutables, por lo que cada llamada a un método produce un nuevo estilo de texto. Puede aplicar estilo de texto en diferentes niveles de diseño:

PdfDocumentBuilder.Create().Generate("text-styles.pdf", doc =>
{
    doc.Pages(page =>
    {
        page.TextStyle(TextStyle.Parent.FontSize(30));

        page.Content()
            .TextStyle(TextStyle.Parent.FontColor(new PdfRgbColor(0, 0, 255)))
            .Text(t =>
            {
                t.Style(TextStyle.Parent.Underline());

                t.Span("Hello PDF").Style(TextStyle.Parent.DirectionRightToLeft());
            });
    });
});

La propiedad TextStyle.Parent devuelve un estilo especial con todas las propiedades del texto sin definir. El ejemplo anterior dibuja "Hello PDF" en azul, subrayado, con un tamaño de fuente de 30 puntos en orden inverso (de derecha a izquierda). Mire el ejemplo Personalizar la apariencia del texto en documentos PDF para ver otro ejemplo de herencia de estilo de texto.

La clase TextStyle admite personalizar todo excepto una fuente asociada. Utilice los métodos Document.TextStyleWithFont cuando necesite especificar una fuente personalizada para su estilo de texto. Este ejemplo de C# muestra cómo utilizar una fuente del sistema:

PdfDocumentBuilder.Create().Generate("fonts.pdf", doc =>
{
    doc.Pages(page =>
    {
        TextStyle style = doc.TextStyleWithFont(SystemFont.Family("Arial").Bold());
        page.Content().Text("Bold text").Style(style);
    });
});

El motor de diseño elimina los glifos de fuentes no utilizados de forma predeterminada. Debido a esto, los documentos generados pueden tener un tamaño pequeño incluso para fuentes grandes. También puede especificar un cargador de fuentes personalizado, fuentes alternativas y un controlador para los glifos faltantes. Consulte el ejemplo Usar diferentes fuentes en documentos PDF para obtener más detalles.

La API de diseño proporciona una colección de estilos predefinidos. Puede usarlos o personalizarlos a través de la clase Typography:

PdfDocumentBuilder.Create().Generate("typography.pdf", doc =>
{
    doc.Typography(t =>
    {
        var baseFont = new FileInfo("arial.ttf");
        t.Document = doc.TextStyleWithFont(baseFont);
        t.Header = t.Parent.FontSize(20).FontColor(new PdfGrayColor(20));
        t.Footer = t.Footnote;
    });

    doc.Pages(page =>
    {
        page.Header().AlignCenter().Text("Header");

        page.Content().Text(t =>
        {
            t.Line("Title").Style(t => t.Title);
            t.Line("Heading 1").Style(t => t.Heading1);
            t.Line("Regular");
        });

        page.Footer().Height(20).AlignCenter().Text(t => t.CurrentPageNumber());
    });
});

Con la clase Typography, no es necesario utilizar variables para mantener las referencias de estilo de texto. Usted registra los estilos necesarios utilizando los métodos Document.Typography y luego los carga desde el objeto Typography. Vea cómo utilizar estilos predefinidos y personalizados en el ejemplo Tipografía.

Imágenes

Al igual que el texto y las fuentes, las imágenes son otra parte fundamental de los documentos PDF. La API de diseño te permite agregar imágenes como esa:

PdfDocumentBuilder.Create().Generate("image.pdf", doc =>
{
    var imageFile = new FileInfo("image.jpg");
    Image image = doc.Image(imageFile);
    doc.Pages(page => page.Content().MaxWidth(200).Image(image));
});

Mesas

La API de diseño le permite generar tablas. Este ejemplo de C# muestra cómo agregar una tabla a un documento PDF:

PdfDocumentBuilder.Create().Generate("table.pdf", doc =>
{
    doc.Pages(page =>
    {
        page.Content().Table(t =>
        {
            t.Columns(c =>
            {
                c.ConstantColumn(200);
                c.RelativeColumn(1);
            });

            t.Header(h =>
            {
                h.Cell().Text("Product");
                h.Cell().Text("Features");
            });

            t.Cell().Text("Docotic.Pdf");
            t.Cell().Text("Extract text, PDF to images, compress PDF");
            t.Cell().Text("Docotic.Pdf.Layout");
            t.Cell().Text("Create PDF");
        });
    });
});

Puede crear tablas de cualquier complejidad. Este ejemplo muestra cómo utilizar los bordes, fondos y espacios de las celdas.

Vínculos internos

Los documentos PDF admiten enlaces internos que le permiten generar marcadores o tablas de contenido. Este ejemplo básico de C# muestra cómo agregar un vínculo a una sección de documento usando la API de diseño:

PdfDocumentBuilder.Create().Generate("link.pdf", doc =>
{
    doc.Pages(page =>
    {
        page.Content().Column(c =>
        {
            const string SectionName = "Chapter 1";
            c.Item().SectionLink(SectionName).Text("Link");

            c.Item().PageBreak();

            c.Item().Section(SectionName).Text("Target");
        });
    });
});

También puede descargar y probar el ejemplo Agregar tabla de contenido a documentos PDF de GitHub.

Diseños complejos

Puede combinar diferentes componentes de diseño para generar documentos PDF complejos. Descargue y pruebe el ejemplo Generar documentos PDF con diseño complejo de GitHub.

Es posible ampliar la API de diseño. Los métodos LayoutContainer.Component y LayoutContainer.Container le permiten reutilizar componentes personalizados. El ejemplo Componentes de diseño muestra cómo implementar un componente personalizado usando la interfaz ILayoutComponent.

Conclusión

Biblioteca Docotic.Pdf proporciona diferentes medios para crear documentos PDF en C# y VB.NET. Puede generar documentos PDF desde cero con o sin usar el complemento de diseño. O puede crear PDF desde HTML usando el complemento HTML a PDF.

Contáctenos si tiene alguna pregunta sobre la generación de PDF.

Recursos Relacionados

• Muestras de API de diseño
• Documentación de API de diseño
• Firmar documentos PDF en C# y VB.NET
• Cifrar documentos PDF en C# y VB.NET
• Convertir HTML a PDF en C# y VB.NET