Esta página puede contener texto traducido automáticamente.
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.
9.5.17573-dev 9.5.17573-dev 9.5.17573-dev14,726 pasaron Descargas totales de NuGet 4,765,230
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 archivo zip con los binarios de la biblioteca. Obtenga la biblioteca, los complementos y una clave de licencia gratuita por tiempo limitado en la página Descargar la biblioteca PDF de C# .NET.
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 contenidoHeader()
- un encabezado común para todas las páginasContent()
- contenido de la página principalFooter()
- un pie de página común para todas las páginasForeground()
- 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.