HTML a PDF

El Documentize PDF Converter for .NET ofrece capacidades robustas para convertir documentos entre formatos HTML y PDF, ideal para aplicaciones web, archivado y generación de informes. Con múltiples opciones para manejar recursos y diseños, el conversor se adapta a diversos requisitos de proyecto.

Conversión de HTML a PDF

Transforme contenido HTML en PDFs de alta calidad, perfectos para generar informes imprimibles, archivar contenido web o crear formatos de documento compartibles. Para convertir un documento HTML a PDF, siga estos pasos:

1. Configure Opciones: Use HtmlToPdfOptions para definir la configuración de diseño y medios.
2. Especifique Rutas: Establezca las rutas del archivo HTML de entrada y del PDF de salida.
3. Ejecute la Conversión: Ejecute el método Convert de PdfConverter para convertir el archivo.

Ejemplo: Convertir HTML a PDF

1// Create HtmlToPdfOptions
2var options = new HtmlToPdfOptions();
3// Add input file path
4options.AddInput(new FileData("path_to_input.html"));
5// Set output file path
6options.AddOutput(new FileData("path_to_output.pdf"));
7//Perform the process
8PdfConverter.Convert(options);

Opciones Adicionales para la Conversión de HTML a PDF

• Tipo de Medio:

  • HtmlMediaType.Print: Ideal para generar PDFs adecuados para impresión.
  • HtmlMediaType.Screen: Úselo al convertir contenido diseñado para visualización digital.

• Ajustes de Diseño:

  • PageLayoutOption: Ajusta cómo el contenido HTML se adapta al diseño del PDF, como ScaleToPageWidth para garantizar que el contenido se escale al ancho del PDF.
  • IsRenderToSinglePage: Permite renderizar todo el contenido HTML en una sola página PDF si se necesita para presentaciones concisas.

Este conversor es versátil para una variedad de aplicaciones, desde generar informes PDF basados en contenido web hasta convertir archivos PDF archivados para accesibilidad basada en la web. Para configuraciones más avanzadas, consulte la documentación completa de Documentize.

PDF a DOC

El Documentize PDF Converter for .NET es una herramienta potente diseñada para convertir documentos PDF a formatos DOC. Este componente transforma sin problemas las páginas PDF en documentos Microsoft Word editables, facilitando la reutilización, edición y compartición del contenido en múltiples plataformas.

Cómo convertir PDF a DOC

Para convertir un documento PDF al formato DOC, siga estos pasos:

1. Cree una instancia de PdfToDocOptions para configurar el proceso de conversión.
2. Añada el archivo PDF de entrada mediante el método AddInput.
3. Añada la ruta del archivo de salida para el archivo resultante mediante el método AddOutput.
4. Ejecute el método Convert para realizar la conversión.

1// Create PdfToDocOptions object to set instructions
2var options = new PdfToDocOptions();
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_file.doc"));
7// Perform the process
8PdfConverter.Convert(options);

Conversión de PDF a DOC con opciones personalizadas

El plugin PDF to DOC Converter ofrece varias opciones para personalizar su proceso de conversión. Puede elegir entre diferentes modos para controlar cómo se maneja el diseño y la estructura del PDF durante la conversión.

 1// Create PdfToDocOptions object to set instructions
 2var options = new PdfToDocOptions();
 3// Add input file path
 4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 5// Set output file path
 6options.AddOutput(new FileData("path_to_result_file.doc"));
 7// Set Mode
 8options.Mode = DocConversionMode.Flow;
 9// Perform the process
10PdfConverter.Convert(options);

Características clave:

• Conversión a DOC: Convierta documentos PDF a formatos Microsoft Word editables (DOC).
• Mantener el formato: Conserve el diseño, texto y formato original durante el proceso de conversión.

PDF a HTML

El Documentize PDF Converter for .NET ofrece capacidades robustas para convertir documentos PDF a formato HTML, ideal para aplicaciones web, archivado y generación de informes. Con múltiples opciones para manejar recursos y diseños, el convertidor se adapta a varios requisitos de proyecto.

Conversión de PDF a HTML

Convierta archivos PDF a HTML para que los documentos sean accesibles en visualizaciones basadas en la web o para integrarlos en aplicaciones donde se prefiere el formato HTML.

1. Configure las opciones: Use PdfToHtmlOptions para personalizar la salida, eligiendo recursos incrustados o externos.
2. Defina las rutas de entrada y salida: Establezca las rutas para su PDF de entrada y el HTML de salida.
3. Ejecute la conversión: Llame al método Convert de PdfConverter para convertir el archivo.

Ejemplo: Convertir PDF a HTML con recursos incrustados

1// Create PdfToHtmlOptions object to set output data type as file with embedded resources
2var options = new PdfToHtmlOptions(PdfToHtmlOptions.SaveDataType.FileWithEmbeddedResources);
3// Add input file path
4options.AddInput(new FileData("path_to_input.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_output.html"));
7//Perform the process
8PdfConverter.Convert(options);

Opciones disponibles para la conversión de PDF a HTML

• SaveDataType:
  • FileWithEmbeddedResources: Genera un único archivo HTML con todos los recursos incrustados.
  • FileWithExternalResources: Guarda los recursos por separado, ideal para archivos HTML grandes.

PDF to JPEG

El Documentize PDF Converter for .NET es una herramienta poderosa que simplifica la conversión de documentos PDF en imágenes JPEG de alta calidad. Este componente está diseñado para hacer que tu contenido sea más accesible en distintas plataformas al transformar páginas PDF en formatos de imagen ampliamente utilizados.

Cómo convertir páginas PDF a JPEG

Para convertir un documento PDF en imágenes JPEG, sigue estos pasos:

1. Crea una instancia de PdfToJpegOptions para configurar el proceso de conversión.
2. Añade el archivo PDF de entrada usando el método AddInput.
3. Establece la ruta del directorio de salida para las imágenes JPEG usando el método AddOutput.
4. Ejecuta el método Convert para convertir las páginas PDF en imágenes JPEG.

1// Create PdfToJpegOptions object to set instructions
2var options = new PdfToJpegOptions();
3// Add input File path
4options.AddInput(new FileData("path_to_input.pdf"));
5// Set output Directory path
6options.AddOutput(new DirectoryData("path_to_output_directory"));
7// Perform the process
8PdfConverter.Convert(options);

Personalizar la conversión de PDF a JPEG

Puedes personalizar el proceso de conversión ajustando la resolución, seleccionando rangos de páginas o configurando la calidad de la imagen. Aquí tienes cómo convertir la primera página de un PDF a 200 DPI:

 1// Create PdfToJpegOptions object to set instructions
 2var options = new PdfToJpegOptions();
 3// Process only the first page
 4options.PageList = [1];
 5// Set output resolution to 200 DPI
 6options.OutputResolution = 200;
 7// Set output quality to 50
 8options.Quality = 50;
 9// Add input File path
10options.AddInput(new FileData("path_to_input.pdf"));
11// Set output Directory path
12options.AddOutput(new DirectoryData("path_to_output_directory"));
13// Perform the process
14PdfConverter.Convert(options);

Obtener resultados sin un directorio o como flujos de datos

El método Convert devuelve un objeto ResultContainer que contiene información sobre los resultados de la conversión. Puedes obtener flujos de los archivos JPEG convertidos como se muestra a continuación:

 1// Create PdfToJpegOptions object to set instructions
 2var options = new PdfToJpegOptions();
 3// Add input File path
 4options.AddInput(new FileData("path_to_input.pdf"));
 5// Perform the process
 6var results = PdfConverter.Convert(options);
 7// Get stream results
 8foreach (var result in results.ResultCollection)
 9{
10    var streamResultPage1 = result.ToStream();
11}

Características clave:

• Convertir PDF a JPEG: Convierte sin esfuerzo documentos PDF completos o páginas específicas en imágenes JPEG.
• Resolución personalizada: Ajusta la resolución (p. ej., 300 dpi) para obtener resultados de alta calidad.
• Conjunto de páginas: Selecciona páginas específicas para la conversión.
• Conversión rápida: Proceso rápido y eficiente con un esfuerzo mínimo.

PDF a PDF/A

El Documentize PDF Converter for .NET es una herramienta potente diseñada para convertir documentos PDF al formato PDF/A, asegurando que su contenido cumpla con los estándares de archivado a largo plazo. Este componente también admite la validación de documentos PDF existentes para el cumplimiento de PDF/A, ofreciendo tanto funciones de conversión como de validación en una única solución.

Cómo convertir PDF a PDF/A

Para convertir un documento PDF al formato PDF/A, siga estos pasos:

1. Cree una instancia de PdfToPdfAOptions para configurar la conversión.
2. Especifique la versión deseada de PDF/A (por ejemplo, PDF/A-3B).
3. Añada el archivo PDF de entrada mediante el método AddInput.
4. Añada el archivo de salida para el PDF/A resultante mediante el método AddOutput.
5. Llame al método Convert para ejecutar la conversión.

 1// Create the options class to set up the conversion process
 2var options = new PdfToPdfAOptions
 3{
 4    PdfAVersion = PdfAStandardVersion.PDF_A_3B
 5};
 6
 7// Add the source file
 8options.AddInput(new FileData("path_to_your_pdf_file.pdf")); // replace with your actual file path
 9
10// Add the path to save the converted file
11options.AddOutput(new FileData("path_to_the_converted_file.pdf"));
12
13// Run the conversion
14PdfConverter.Convert(options);

Validación de cumplimiento PDF/A

Puede validar archivos PDF existentes para el cumplimiento de PDF/A usando la clase PdfAValidateOptions.

 1// Create the options class to set up the validation process
 2var options = new PdfAValidateOptions
 3{
 4    PdfAVersion = PdfAStandardVersion.PDF_A_1A
 5};
 6
 7// Add one or more files to be validated
 8options.AddInput(new FileData("path_to_your_first_pdf_file.pdf")); // replace with your actual file path
 9options.AddInput(new FileData("path_to_your_second_pdf_file.pdf"));
10// add more files as needed
11
12// Run the validation and get results
13var resultContainer = PdfConverter.Validate(options);
14
15// Check the resultContainer.ResultCollection property for validation results for each file:
16foreach (var result in resultContainer.ResultCollection)
17{
18    var validationResult = (PdfAValidationResult) result.Data;
19    var isValid = validationResult.IsValid; // Validation result for document
20}

Características principales:

• Convertir a PDF/A: Transforme sin problemas archivos PDF al formato PDF/A (como PDF/A-1a, PDF/A-2b, PDF/A-3b) para garantizar el cumplimiento de los estándares de archivado.
• Validar cumplimiento PDF/A: Verifique los documentos PDF existentes para asegurarse de que cumplan con los estándares PDF/A e identifique problemas si no lo hacen.
• Flujo de trabajo eficiente: Reduzca tiempo y esfuerzo con procesos de conversión rápidos y confiables.

PDF a PNG

El Documentize PDF Converter for .NET es una herramienta avanzada que permite convertir documentos PDF en imágenes PNG de alta calidad. Este componente está diseñado para que tu contenido sea más versátil, accesible y fácil de compartir al transformar páginas PDF en formatos de imagen ampliamente compatibles.

Cómo convertir PDF a PNG

Para convertir un documento PDF en imágenes PNG, sigue estos pasos:

1. Crea una instancia de PdfToPngOptions para configurar el proceso de conversión.
2. Añade el archivo PDF de entrada usando el método AddInput.
3. Establece la ruta del directorio de salida para las imágenes PNG usando el método AddOutput.
4. Ejecuta el método Convert para convertir las páginas del PDF en imágenes PNG.

1// Create PdfToPngOptions object to set instructions
2var options = new PdfToPngOptions();
3// Add input File path
4options.AddInput(new FileData("path_to_input.pdf"));
5// Set output Directory path
6options.AddOutput(new DirectoryData("path_to_output_directory"));
7// Perform the process
8PdfConverter.Convert(options);

Personalizar la conversión de PDF a PNG

Puedes personalizar la conversión ajustando la resolución y seleccionando páginas específicas. Por ejemplo, para convertir solo la primera página de un PDF a 200 DPI:

 1// Create PdfToPngOptions object to set instructions
 2var options = new PdfToPngOptions()
 3// Process only the first page
 4options.PageList = [1];
 5// Set output resolution to 200 DPI
 6options.OutputResolution = 200;
 7// Add input File path
 8options.AddInput(new FileData("path_to_input.pdf"));
 9// Set output Directory path
10options.AddOutput(new DirectoryData("path_to_output_directory"));
11// Perform the process
12PdfConverter.Convert(options);

Manejo de los resultados de la conversión

El método Convert devuelve un objeto ResultContainer que contiene información sobre los resultados de la conversión. Puedes obtener los flujos de los archivos PNG convertidos como se muestra a continuación:

 1// Create PdfToJpegOptions object to set instructions
 2var options = new PdfToPngOptions();
 3// Add input File path
 4options.AddInput(new FileData("path_to_input.pdf"));
 5// Perform the process
 6var results = PdfConverter.Convert(options);
 7// Get stream results
 8foreach (var result in results.ResultCollection)
 9{
10    var streamResultPage1 = result.ToStream();
11}

Características clave:

• Convertir PDF a PNG: Convierte rápida y eficientemente documentos PDF completos o páginas específicas en imágenes PNG.
• Resolución personalizable: Define el DPI deseado (p. ej., 300 DPI) para obtener imágenes de alta calidad.
• Conjunto de páginas: Selecciona páginas específicas para la conversión.
• Gestión fácil de la salida: Especifica directorios de salida para cada archivo PNG convertido.
• Conversión rápida: Rápida, eficiente y requiere un mínimo esfuerzo de configuración.

PDF a TIFF

El Documentize PDF Converter for .NET es una herramienta potente diseñada para convertir documentos PDF en imágenes TIFF de alta calidad. Este componente asegura que tu contenido sea accesible en diversas plataformas manteniendo una excelente fidelidad y versatilidad.
Puedes personalizar el proceso de conversión ajustando la resolución, habilitando la salida multipágina o seleccionando páginas.

Cómo convertir PDF a TIFF

Para convertir un documento PDF en imágenes TIFF, sigue estos pasos:

1. Crea una instancia de PdfToTiffOptions para configurar el proceso de conversión.
2. Añade el archivo PDF de entrada usando el método AddInput.
3. Especifica la ruta del archivo de salida para las imágenes TIFF usando el método AddOutput.
4. Ejecuta el método Convert para convertir las páginas del PDF en imágenes TIFF.

1  
2// Create PdfToTiffOptions object to set instructions  
3var options = new PdfToTiffOptions();  
4// Add input file path  
5options.AddInput(new FileData("path_to_your_pdf_file.pdf"));  
6// Set output Directory path  
7options.AddOutput(new DirectoryData("path_to_output_directory"));  
8// Perform the process  
9PdfConverter.Convert(options);  

Personalizar páginas y DPI de la conversión de PDF a TIFF

Así es como conviertes 2 páginas de un PDF a 400 DPI en un archivo TIFF:

 1  
 2// Create PdfToTiffOptions object to set instructions  
 3var options = new PdfToTiffOptions();  
 4// Add input file path  
 5options.AddInput(new FileData("path_to_your_pdf_file.pdf"));  
 6// Set output Directory path  
 7options.AddOutput(new DirectoryData("path_to_output_directory"));  
 8// Set Pages  
 9options.PageList = [1, 3];  
10// Set result image Resolution  
11options.OutputResolution = 400;  
12// Perform the process  
13PdfConverter.Convert(options);  

Creación de TIFF multipágina

El complemento soporta la generación de TIFF multipágina, lo que permite combinar varias páginas PDF en un solo archivo TIFF para un archivado o impresión eficientes.

 1  
 2// Create PdfToTiffOptions object to set instructions  
 3var options = new PdfToTiffOptions();  
 4// Add input file path  
 5options.AddInput(new FileData("path_to_your_pdf_file.pdf"));  
 6// Set output Directory path  
 7options.AddOutput(new DirectoryData("path_to_output_directory"));  
 8// Enable Multi-Page TIFF output  
 9options.MultiPage = true;  
10// Perform the process  
11PdfConverter.Convert(options);  

Personalizar compresión y profundidad de color

Así es como conviertes 2 páginas de un PDF a 400 DPI en un archivo TIFF con compresión y profundidad de color específicas:

 1  
 2// Create PdfToTiffOptions object to set instructions  
 3var options = new PdfToTiffOptions();  
 4// Add input file path  
 5options.AddInput(new FileData("path_to_your_pdf_file.pdf"));  
 6// Set output Directory path  
 7options.AddOutput(new DirectoryData("path_to_output_directory"));  
 8// Set Compression and ColorDepth  
 9options.Compression = TiffCompression.RLE;  
10options.ColorDepth = TiffColorDepth.Format24bpp;  
11// Perform the process  
12PdfConverter.Convert(options);  

Cómo manejar los resultados de la conversión

El método Convert devuelve un objeto ResultContainer que proporciona detalles sobre los resultados de la conversión. Puedes obtener flujos de los archivos TIFF convertidos como se muestra a continuación:

 1  
 2// Create PdfToTiffOptions object to set instructions  
 3var options = new PdfToTiffOptions();  
 4// Add input File path  
 5options.AddInput(new FileData("path_to_input.pdf"));  
 6// Perform the process  
 7var results = PdfConverter.Convert(options);  
 8// Get stream results  
 9foreach (var result in results.ResultCollection)  
10{  
11    var streamResultPage1 = result.ToStream();  
12}  

Características clave:

• Convertir PDF a TIFF: Convierte fácilmente documentos PDF completos o páginas específicas en imágenes TIFF.
• Resolución personalizada: Ajusta la resolución (por ejemplo, 300 dpi) para obtener resultados de alta calidad.
• TIFF multipágina: Combina varias páginas PDF en un solo archivo TIFF multipágina.
• Conjunto de páginas: Selecciona páginas específicas para la conversión.
• Conversión rápida: Proceso rápido y eficiente con un esfuerzo mínimo.

PDF a XLS

El Documentize PDF Converter for .NET es una herramienta versátil y potente para convertir documentos PDF en hojas de cálculo Excel (XLSX/XLS/CSV/XLSM/ODS). Al aprovechar este componente, los desarrolladores pueden transformar sin esfuerzo datos estáticos de PDF en hojas de cálculo dinámicas y editables, simplificando la manipulación, el análisis y el intercambio de datos.

Cómo convertir PDF a Excel

Para convertir un documento PDF en un archivo Excel (XLSX), sigue estos pasos:

1. Configura los ajustes de conversión usando la clase PdfToXlsOptions.
2. Añade los archivos PDF de entrada con el método AddInput.
3. Especifica la ruta del archivo de salida con el método AddOutput.
4. Ejecuta el método Convert para iniciar la conversión.

1  
2// Create PdfToXlsOptions object to set instructions  
3var options = new PdfToXlsOptions();  
4// Add input file path  
5options.AddInput(new FileData("path_to_your_pdf_file.pdf"));  
6// Set output file path  
7options.AddOutput(new FileData("path_to_result_xlsx_file.xlsx"));  
8// Perform the process  
9PdfConverter.Convert(options);  

Personalizar la conversión de PDF a Excel

La clase PdfToXlsOptions permite personalizar el proceso de conversión. Por ejemplo, para convertir el PDF a un archivo XLS y habilitar opciones avanzadas de formato:

 1  
 2// Create PdfToXlsOptions object to set instructions  
 3var options = new PdfToXlsOptions();  
 4// Add input file path  
 5options.AddInput(new FileData("path_to_your_pdf_file.pdf"));  
 6// Specify XLS format  
 7options.Format = PdfToXlsOptions.ExcelFormat.XMLSpreadSheet2003;  
 8options.InsertBlankColumnAtFirst = true;  
 9options.MinimizeTheNumberOfWorksheets = true;  
10// Set output file path  
11options.AddOutput(new FileData("path_to_result_xlsx_file.xls"));  
12// Perform the process  
13PdfConverter.Convert(options);  

Formatos de salida compatibles

El enumerado PdfToXlsOptions.ExcelFormat ofrece una variedad de formatos de salida:

• XLSX: Formato de archivo Office Open XML (.xlsx) (predeterminado).
• XLSM: Formato Excel con macros.
• CSV: Valores separados por comas.
• ODS: Hoja de cálculo de Open Document.
• XMLSpreadSheet2003: Formato XML de Excel 2003 (.xls).

Características clave:

• Opciones de conversión flexibles: Convierte archivos PDF a XLSX, XLS, CSV u otros formatos.
• Preservación del contenido: Mantiene la estructura, el diseño y el formato originales.
• Formato avanzado: Inserta columnas en blanco o minimiza la cantidad de hojas de cálculo.

Extraer Texto

El Documentize PDF Extractor for .NET simplifica la extracción de texto de documentos PDF. Ya sea que necesites texto puro, sin formato o simple, este complemento te permite extraer texto de manera eficiente, preservando el formato o omitiéndolo según tus requerimientos.

Cómo extraer texto de un archivo PDF

Para extraer texto de un archivo PDF, sigue estos pasos:

1. Crea una instancia de ExtractTextOptions para configurar la ruta del archivo de entrada.
2. Ejecuta el método Extract para extraer el texto.

1// Create ExtractTextOptions object to set input file path
2var options = new ExtractTextOptions("path_to_your_pdf_file.pdf");
3// Perform the process and get the extracted text
4var textExtracted = PdfExtractor.Extract(options);

Cómo extraer texto de un flujo PDF

Para extraer texto de un flujo PDF, sigue estos pasos:

1. Crea una instancia de ExtractTextOptions para configurar el flujo de entrada.
2. Ejecuta el método Extract para extraer el texto.

1// Create ExtractTextOptions object to set input stream
2var stream = File.OpenRead("path_to_your_pdf_file.pdf");
3var options = new ExtractTextOptions(stream);
4// Perform the process and get the extracted text
5var textExtracted = PdfExtractor.Extract(options);

Modos de extracción de texto

El ExtractTextOptions ofrece tres modos de extracción, proporcionando flexibilidad según tus necesidades.

1. Modo Puro: Preserva el formato original, incluidos los espacios y la alineación.
2. Modo Crudo: Extrae el texto sin formato, útil para el procesamiento de datos sin procesar.
3. Modo Aplanado: Representa el contenido del PDF con fragmentos de texto posicionados por sus coordenadas.

1// Create ExtractTextOptions object to set input file path and TextFormattingMode
2var options = new ExtractTextOptions("path_to_your_pdf_file.pdf", TextFormattingMode.Pure);
3// Perform the process and get the extracted text
4var textExtracted = PdfExtractor.Extract(options);

Cómo extraer texto de un archivo PDF en el estilo más conciso posible

1// Perform the process and get the extracted text
2var textExtracted = PdfExtractor.Extract(new ExtractTextOptions("path_to_your_pdf_file.pdf", TextFormattingMode.Pure));

Características clave:

• Modo Puro: Extrae texto mientras preserva su formato original.
• Modo Crudo: Extrae texto sin ningún formato.
• Modo Aplanado: Extrae texto sin caracteres especiales ni formato.

Extract Images

El plugin Documentize PDF Extractor for .NET le permite extraer imágenes sin esfuerzo de documentos PDF. Escanea sus archivos PDF, identifica las imágenes incrustadas y las extrae manteniendo su calidad y formato originales. Esta herramienta mejora la accesibilidad del contenido visual y agiliza el proceso de recuperación de imágenes de PDFs.

Cómo extraer imágenes de un PDF

1. Cree una instancia de la clase ExtractImagesOptions.
2. Añada la ruta del archivo de entrada a las opciones usando el método AddInput.
3. Establezca la ruta del directorio de salida para las imágenes usando el método AddOutput.
4. Procese la extracción de imágenes usando el plugin.
5. Recupere las imágenes extraídas del contenedor de resultados.

 1// Create ExtractImagesOptions to set instructions
 2var options = new ExtractImagesOptions();
 3// Add input file path
 4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 5// Set output Directory path
 6options.AddOutput(new DirectoryData("path_to_results_directory"));
 7// Perform the process
 8var results = PdfExtractor.Extract(options);
 9// Get path to image result
10var imageExtracted = results.ResultCollection[0].ToFile();

Extracción de imágenes de un archivo PDF a streams sin carpeta

El plugin PdfExtractor admite guardar en streams, lo que le permite extraer imágenes de archivos PDF a streams sin usar carpetas temporales.

 1// Create ExtractImagesOptions to set instructions
 2var options = new ExtractImagesOptions();
 3// Add input file path
 4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 5// Not set output - it will write results to streams
 6// Perform the process
 7var results = PdfExtractor.Extract(options);
 8// Get Stream
 9var ms = results.ResultCollection[0].ToStream();
10// Copy data to file for demo
11ms.Seek(0, SeekOrigin.Begin);
12using (var fs = File.Create("test_file.png"))
13{
14    ms.CopyTo(fs);
15}

Características clave:

• Extraer imágenes incrustadas: Identificar y extraer imágenes de documentos PDF.
• Preservar la calidad de la imagen: Garantiza que las imágenes extraídas mantengan su calidad original.
• Salida flexible: Guarde las imágenes extraídas en el formato o ubicación que prefiera.

Extraer Propiedades / Metadatos

El Documentize PDF Extractor for .NET simplifica la extracción de metadatos de documentos PDF.
Propiedades disponibles que pueden interesarte: FileName, Title, Author, Subject, Keywords, Created, Modified, Application, PDF Producer, Number of Pages.

Cómo extraer metadatos de un archivo PDF

El ejemplo muestra cómo extraer propiedades (Title, Author, Subject, Keywords, Number of Pages) de un archivo PDF.
Para extraer metadatos de un documento PDF, sigue estos pasos:

1. Crea una instancia de ExtractPropertiesOptions para configurar las opciones de extracción y el archivo PDF de entrada.
2. Ejecuta el método Extract de PdfExtractor para obtener los metadatos.
3. Accede a las propiedades extraídas mediante PdfProperties.

 1// Create ExtractPropertiesOptions object to set input file
 2var options = new ExtractPropertiesOptions("path_to_your_pdf_file.pdf");
 3// Perform the process and get Properties
 4var pdfProperties = PdfExtractor.Extract(options);
 5var filename = pdfProperties.FileName;
 6var title = pdfProperties.Title;
 7var author = pdfProperties.Author;
 8var subject = pdfProperties.Subject;
 9var keywords = pdfProperties.Keywords;
10var created = pdfProperties.Created;
11var modified = pdfProperties.Modified;
12var application = pdfProperties.Application;
13var pdfProducer = pdfProperties.PdfProducer;
14var numberOfPages = pdfProperties.NumberOfPages;

Cómo extraer metadatos de un flujo (stream) PDF

Puedes abrir el flujo a tu discreción.

 1// Create ExtractPropertiesOptions object to set input stream
 2var stream = File.OpenRead("path_to_your_pdf_file.pdf");
 3var options = new ExtractPropertiesOptions(stream);
 4// Perform the process and get Properties
 5var pdfProperties = PdfExtractor.Extract(options);
 6var title = pdfProperties.Title;
 7var author = pdfProperties.Author;
 8var subject = pdfProperties.Subject;
 9var keywords = pdfProperties.Keywords;
10var created = pdfProperties.Created;
11var modified = pdfProperties.Modified;
12var application = pdfProperties.Application;
13var pdfProducer = pdfProperties.PdfProducer;
14var numberOfPages = pdfProperties.NumberOfPages;

Cómo extraer metadatos de un archivo PDF en el estilo más corto posible

1// Perform the process and get Properties
2var pdfProperties = PdfExtractor.Extract(new ExtractPropertiesOptions("path_to_your_pdf_file.pdf"));

Características clave:

• Metadatos disponibles: FileName, Title, Author, Subject, Keywords, Created, Modified, Application, PDF Producer, Number of Pages.

Exportar datos del formulario

El Documentize PDF Extractor for .NET plugin ofrece una forma fluida de extraer y exportar datos de formularios PDF (AcroForms) a otros formatos como CSV. Esta herramienta dinámica simplifica el proceso de obtención de los valores de los campos del formulario, permitiendo una gestión, transferencia y análisis de datos más sencillo.

Cómo exportar datos de formulario de PDF a CSV

Para exportar datos de formulario de un PDF a CSV, sigue estos pasos:

1. Crea una instancia de la clase ExtractImagesOptions.
2. Define las opciones de exportación usando la clase FormExporterValuesToCsvOptions.
3. Añade los archivos PDF de entrada y especifica el archivo CSV de salida.
4. Ejecuta el método Extract para realizar la exportación.

1// Create ExtractFormDataToDsvOptions object to set instructions
2var options = new ExtractFormDataToDsvOptions(',', true);
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_csv_file.csv"));
7// Perform the process
8PdfExtractor.Extract(options);

Cómo exportar datos de formulario de PDF a TSV

Usa Tab como delimitador.

 1// Create ExtractFormDataToDsvOptions object to set instructions
 2var options = new ExtractFormDataToDsvOptions();
 3//Set Delimiter
 4options.Delimiter = '\t';
 5//Add Field Names to result
 6options.AddFieldName = true;
 7// Add input file path
 8options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 9– Set output file path
10options.AddOutput(new FileData("path_to_result_csv_file.tsv"));
11– Perform the process
12PdfExtractor.Extract(options);

Características clave:

• Exportar datos de formulario: Extrae datos de formularios PDF (AcroForms) a CSV u otros formatos.
• Filtrado de datos: Usa predicados para filtrar campos específicos del formulario para la exportación según criterios como tipo de campo o número de página.
• Salida flexible: Guarda los datos exportados para su análisis o transferencia a hojas de cálculo, bases de datos u otros formatos de documento.

Combinar PDF

El Documentize PDF Manager for .NET es una herramienta versátil diseñada para combinar varios documentos PDF en un solo archivo. Simplifica la consolidación de archivos PDF, asegurando que tus documentos se fusionen de manera eficiente y manteniendo la consistencia del contenido. El componente gestiona recursos internos como fuentes e imágenes para optimizar el documento combinado.

Cómo combinar PDF

Para combinar varios documentos PDF en un solo archivo, sigue estos pasos:

1. Crea una instancia de MergeOptions para configurar el proceso de combinación.
2. Añade los archivos PDF de entrada usando el método AddInput.
3. Añade el archivo PDF de salida usando el método AddOutput.
4. Ejecuta la combinación usando el método Merge de la clase PdfManager.

1// Create MergeOptions object to set instructions
2var options = new MergeOptions();
3// Add input file paths
4options.AddInput(new FileData("path_to_your_pdf_file_1.pdf"));
5options.AddInput(new FileData("path_to_your_pdf_file_2.pdf"));
6// Set output file path
7options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
8// Perform the process
9PdfManager.Merge(options);

Características clave:

• Merge Multiple PDFs: Easily combine multiple PDF files into one.
• Resource Optimization: Removes duplicate fonts and images during merging.
• Batch Processing: Merge large batches of PDF documents in one go.

Dividir PDF

El Documentize PDF Manager for .NET es una herramienta potente que simplifica el proceso de dividir documentos PDF grandes en archivos más pequeños y manejables. Ya sea que necesites extraer páginas individuales o dividir un documento en secciones específicas, este componente te permite lograrlo de manera eficiente y con mínimo esfuerzo.

Cómo dividir PDF

Para dividir un documento PDF en páginas individuales, sigue estos pasos:

1. Crea una instancia de SplitOptions para configurar las opciones de división.
2. Añade el archivo PDF de entrada usando el método AddInput.
3. Añade archivos de salida para cada página dividida usando el método AddOutput.
4. Ejecuta el método Split en la clase PdfManager para dividir el documento.

1// Create SplitOptions object to set instructions
2var options = new SplitOptions();
3// Add input file path
4options.AddInput(new FileDataSource("path_to_your_pdf_file.pdf"));
5// Set output file paths
6options.AddOutput(new FileData("path_to_result_pdf_file_1.pdf"));
7options.AddOutput(new FileData("path_to_result_pdf_file_2.pdf"));
8// Perform the process
9PdfManager.Split(options);

Características clave:

• Dividir PDF por página: Desglosa un documento PDF en páginas individuales.
• Opciones de división personalizadas: Configura el proceso de división según tus requerimientos.
• Salida organizada: Gestiona fácilmente los archivos de salida para cada página o sección dividida.

Comprimir PDF

El PDF Manager es una herramienta integral que mejora los documentos PDF mediante técnicas avanzadas de optimización. Estas operaciones Comprimen documentos PDF, facilitando su almacenamiento, compartición y visualización.

Comprimir PDF

Comprime el documento PDF cuando sea posible eliminando recursos de página no utilizados, fusionando activos idénticos y descartando objetos redundantes.

1. Crea un objeto CompressOptions para configurar las opciones de optimización.
2. Añade el archivo de entrada y especifica la ubicación del archivo de salida.
3. Usa el método SetCropBox para definir el área de recorte.
4. Ejecuta el método Compress de PdfManager.

1// Create CompressOptions object to set instructions
2var options = new CompressOptions();
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
7// Perform the process
8PdfManager.Compress(options);

Características clave:

• Compresión: Elimina recursos y objetos de página no utilizados del documento.

Optimizar PDF

El PDF Manager es una herramienta integral que mejora los documentos PDF mediante técnicas avanzadas de optimización. Está diseñada para ayudar a reducir el tamaño de los archivos, rotar páginas, recortar contenido y cambiar el tamaño de los documentos. Estas operaciones mejoran la calidad y la manejabilidad de los archivos PDF, facilitando su almacenamiento, compartición y visualización. La optimización, o linealización para la Web, se refiere al proceso de hacer que un archivo PDF sea adecuado para la navegación en línea mediante un navegador web.

Optimizar PDF

Los pasos siguientes demuestran cómo optimizar un documento PDF reduciendo su tamaño de archivo sin perder calidad.

1. Crear un objeto OptimizeOptions para configurar los ajustes de optimización.
2. Añadir el(los) archivo(s) PDF de entrada y establecer una ubicación de salida para el archivo optimizado.
3. Ejecutar el método Optimize de PdfManager para llevar a cabo la optimización.

1// Create OptimizeOptions object to set instructions
2var options = new OptimizeOptions();
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
7// Perform the process
8PdfManager.Optimize(options);

Características clave:

• Optimización: Reduce el tamaño del archivo PDF sin perder calidad.

Redimensionar páginas de PDF

Puedes redimensionar páginas de documentos PDF usando la clase PDF Manager. Después de crear un ResizeOptions, puedes establecer el tamaño de página deseado y ejecutar el proceso de redimensionado. El PDF resultante reflejará las nuevas dimensiones, asegurando que cumpla con requisitos específicos.

Redimensionar PDF

Para redimensionar un documento PDF, se utiliza la clase ResizeOptions para especificar el nuevo tamaño de página del documento.

1. Crea un objeto ResizeOptions para definir el tamaño de página.
2. Añade el archivo de entrada y establece la ubicación de salida deseada.
3. Usa el método SetPageSize para especificar el nuevo tamaño (p. ej., A4).
4. Ejecuta el método Resize de PdfManager.

 1// Create ResizeOptions object to set instructions
 2var options = new ResizeOptions();
 3// Set new PageSize
 4options.PageSize = PageSize.A3;
 5// Add input file path
 6options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 7// Set output file path
 8options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
 9// Perform the process
10PdfManager.Resize(options);

Características clave:

• Redimensionamiento: Redimensionar páginas a dimensiones específicas
• Tamaños disponibles: A0, A1, A2, A3, A4, A4, A5, A6, B5, Letter, Legal, Ledger, 11x17 inches.

Rotar páginas de PDF

Puedes rotar páginas de documentos PDF usando la clase PDF Manager. Después de crear un RotateOptions, puedes establecer el ángulo de página deseado y ejecutar el proceso. El PDF resultante reflejará las nuevas dimensiones, asegurando que cumpla con requisitos específicos.

Rotar PDF

Usa la clase RotateOptions para ajustar la orientación de las páginas en un archivo PDF.

1. Crea un objeto RotateOptions y configura el ángulo de rotación.
2. Añade el archivo PDF de entrada y especifica la ubicación del archivo de salida.
3. Establece el ángulo de rotación (p.ej., 90 grados) usando el método SetRotation.
4. Ejecuta el método Rotate de PdfManager.

 1// Create RotateOptions object to set instructions
 2var options = new RotateOptions();
 3// Set new Rotation
 4options.Rotation = Rotation.On90;
 5// Add input file path
 6options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 7// Set output file path
 8options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
 9// Perform the process
10PdfManager.Rotate(options);

Características clave:

• Rotation: Ajusta la orientación de las páginas PDF.

Agregar Tabla

El Documentize PDF Manager para .NET es un componente versátil diseñado para simplificar la integración de tablas en documentos PDF. Ya sea que esté organizando datos, diseñando formularios o mejorando la legibilidad de documentos, este componente simplifica el proceso manteniendo precisión y eficiencia.

Creación de un PDF con Tablas

Siga estos pasos para crear tablas estructuradas en un PDF usando la clase TableOptions:

1. Configure el objeto TableOptions para definir la estructura de la tabla, el contenido y los archivos de entrada/salida.
2. Añada tablas, filas y celdas a su PDF.
3. Finalice el proceso de generación de la tabla usando el método AddTable.

Aquí tienes un ejemplo:

 1// Configure table options
 2var options = new TableOptions();
 3options.InsertPageBefore(1)
 4   .AddTable()
 5        .AddRow()
 6            .AddCell().AddParagraph("Name")
 7            .AddCell().AddParagraph("Age")
 8        .AddRow()
 9            .AddCell().AddParagraph("Bob")
10            .AddCell().AddParagraph("12")
11        .AddRow()
12            .AddCell().AddParagraph("Sam")
13            .AddCell().AddParagraph("20")
14        .AddRow()
15            .AddCell().AddParagraph("Sandy")
16            .AddCell().AddParagraph("26")
17        .AddRow()
18            .AddCell().AddParagraph("Tom")
19            .AddCell().AddParagraph("12")
20        .AddRow()
21            .AddCell().AddParagraph("Jim")
22            .AddCell().AddParagraph("27");
23// Add input file path
24options.AddInput(new FileData("path_to_input.pdf"));
25// Set output file path
26options.AddOutput(new FileData("path_to_output.pdf"));
27// Perform the process
28PdfManager.AddTable(options);

Establecer la página de la tabla

Siga estos pasos para crear una tabla en un PDF antes de la página 2: Aquí tienes un ejemplo:

 1// Configure table options
 2var options = new TableOptions();
 3options.InsertPageBefore(2) // Add table before page 2
 4   .AddTable()
 5        .AddRow()
 6            .AddCell().AddParagraph("Name")
 7            .AddCell().AddParagraph("Age");
 8// Add input file path
 9options.AddInput(new FileData("path_to_input.pdf"));
10// Set output file path
11options.AddOutput(new FileData("path_to_output.pdf"));
12// Perform the process
13PdfManager.AddTable(options);

Principales características:

• Creación dinámica de tablas: Genere tablas estructuradas en documentos PDF sin esfuerzo.
• Ubicación en la página: Inserte tablas en ubicaciones específicas dentro de un PDF con precisión.
• Diseño personalizable: Ajuste la estructura de la tabla, la alineación de celdas y el estilo.

Agregar índice

El Documentize PDF Manager for .NET es un componente potente diseñado para mejorar la organización y navegación de documentos PDF generando dinámicamente una Tabla de Contenidos (TOC). Este componente simplifica el proceso de añadir índices a tus PDFs, haciendo que los documentos sean más fáciles de navegar y gestionar.

Cómo generar un índice para un PDF

Para crear una Tabla de Contenidos en un archivo PDF, sigue estos pasos:

1. Crea una instancia de TocOptions para configurar los ajustes de generación del índice.
2. Define un título mediante la propiedad Title.
3. Diseña los encabezados del índice usando el método Headings.Add.
4. Añade el archivo PDF de entrada mediante el método AddInput.
5. Especifica el archivo PDF de salida con el índice usando el método AddOutput.
6. Llama al método AddTableOfContents para generar el índice.

 1// Create TocOptions object to set instructions
 2var options = new TocOptions();
 3// Set the Title
 4options.Title = "My Table of Contents";
 5// Design Headings
 6options.Headings.Add(new TocHeading("Introduction", 2));
 7options.Headings.Add(new TocHeading("Chapter I", 3));
 8options.Headings.Add(new TocHeading("Chapter II", 4));
 9options.Headings.Add(new TocHeading("Chapter III", 5));
10// Add input file path
11options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
12// Set output file path
13options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
14// Perform the process
15PdfManager.AddTableOfContents(options);

Generar marcadores en un índice para un PDF

Puedes usar la propiedad GenerateBookmarks para la generación de marcadores.

 1// Create TocOptions object to set instructions
 2var options = new TocOptions();
 3// Set the Title
 4options.Title = "My Table of Contents";
 5// Generate links in bookmarks
 6options.GenerateBookmarks = true;
 7// Design Headings
 8options.Headings.Add(new TocHeading("Introduction", 2, false, 1));
 9options.Headings.Add(new TocHeading("Chapter I", 3, true, 1));
10options.Headings.Add(new TocHeading("Chapter II", 4, true, 1));
11options.Headings.Add(new TocHeading("Example A", 4, true, 2));
12options.Headings.Add(new TocHeading("Example B", 4, true, 2));
13options.Headings.Add(new TocHeading("Example C", 4, true, 2));
14options.Headings.Add(new TocHeading("Example D", 4, true, 2));
15options.Headings.Add(new TocHeading("Chapter III", 5, true, 1));
16// Add input file path
17options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
18// Set output file path
19options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
20// Perform the process
21PdfManager.AddTableOfContents(options);

Cómo obtener el resultado como Stream

 1// Create TocOptions object to set instructions
 2var options = new TocOptions();
 3// Set the Title
 4options.Title = "My Table of Contents";
 5// Design Headings
 6options.Headings.Add(new TocHeading("Introduction", 2, false, 1));
 7// Add input file path
 8options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 9// Set output stream 
10var outputStream = new MemoryStream();
11options.AddOutput(new StreamData(outputStream));
12options.CloseOutputStreams = false;
13// Perform the process
14PdfManager.AddTableOfContents(options);

Personalizar el encabezado del índice

Puedes personalizar el encabezado de la Tabla de Contenidos modificando la clase TocHeading. Por ejemplo, puedes usar GenerateNumbering o hacerlo manualmente.
La propiedad PageNumber se usa para los enlaces a páginas. También puedes usar la propiedad Level.

 1// Create TocOptions object to set instructions
 2var heading = new TocHeading();
 3heading.Text = "Intro";
 4heading.PageNumber = 5;
 5heading.GenerateNumbering = true;
 6heading.Level = 2;
 7var tocOptions = new TocOptions();
 8options.Headings.Add(heading);
 9// Add input and output files
10tocOptions.AddInput(new FileData("path_to_your_pdf_file.pdf"));
11tocOptions.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
12// Generate the TOC with customized options
13PdfManager.AddTableOfContents(tocOptions);

Características clave:

• Generación dinámica de índices: Crea un índice para cualquier archivo PDF con entradas generadas automáticamente a partir de encabezados o marcadores.
• Personalización: Controla la apariencia y estructura del índice, incluidos estilos, formato y niveles de profundidad.
• Flujo de trabajo eficiente: Reduce el tiempo dedicado a crear índices manualmente, especialmente en documentos grandes o complejos.

Use ChatGPT

El plugin Documentize PDF Manager for .NET es una herramienta potente diseñada para integrar la API de ChatGPT con aplicaciones PDF. Este plugin permite a los desarrolladores generar respuestas de chat basadas en mensajes de entrada y guardar la salida en formato PDF, lo que lo hace ideal para crear interfaces conversacionales o informes de análisis directamente dentro de documentos PDF.

Generar respuestas de chat

Para generar respuestas de chat y guardarlas en un archivo PDF usando el plugin de ChatGPT, sigue estos pasos:

1. Crea una instancia de la clase ChatGptRequestOptions para configurar las opciones de la solicitud.
2. Añade los archivos PDF de entrada y salida.
3. Establece la clave API y especifica parámetros como la cantidad máxima de tokens y la consulta para el modelo de ChatGPT.
4. Ejecuta el método CreatePdfByChatGptRequestAsync para generar la finalización del chat.

 1var options = new ChatGptRequestOptions();
 2// Set output file path
 3options.AddOutput(new FileData("path_to_result_pdf_file.pdf")); 
 4options.ApiKey = "Your API key."; // You need to provide the key to access the API.
 5options.MaxTokens = 1000; // The maximum number of tokens to generate in the chat completion.
 6
 7// Add the request messages.
 8options.Messages.Add(new Message
 9{
10    Content = "You are a helpful assistant.",
11    Role = Role.System
12});
13options.Messages.Add(new Message
14{
15    Content = "What is the biggest pizza diameter ever made?",
16    Role = Role.User
17});
18
19// Process the request.
20var result = await PdfManager.CreatePdfByChatGptRequestAsync(options);
21
22var fileResultPath = result.ResultCollection[0].Data;
23var chatCompletionObject = result.ResultCollection[1].Data as ChatCompletion; // The ChatGPT API chat completion object.

Añadir mensajes del sistema y del usuario

Para crear una conversación más interactiva, puedes añadir tanto mensajes del sistema como del usuario. Estos mensajes ayudan a definir el contexto de la conversación.

1. Añade un mensaje del sistema que establezca el contexto para ChatGPT.
2. Añade un mensaje del usuario que represente la entrada del usuario en la conversación.

 1var options = new ChatGptRequestOptions();
 2// Set output file path
 3options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
 4
 5// Add the PDF text source.
 6// In case of multiple sources, the text from each document will be added to the request message collection
 7// as a separate message with the role "user".
 8options.AddInput(new FileData("TextSource.pdf"));
 9
10options.ApiKey = "Your API key."; // You need to provide the key to access the API.
11options.MaxTokens = 1000; // The maximum number of tokens to generate in the chat completion.
12
13// Add the request message.
14// In this case, the system message with Content = "You are a helpful assistant." is added by default.
15// The role of the query message is "user" by default.
16options.Query = "How many letters in the provided text?";
17
18// Process the request.
19var result = await PdfManager.CreatePdfByChatGptRequestAsync(options);
20
21var fileResultPath = result.ResultCollection[0].Data;
22var chatCompletionObject = result.ResultCollection[1].Data as ChatCompletion; // The ChatGPT API chat completion object.

Características clave:

• Chat Completions: Genera respuestas usando la API de ChatGPT basadas en entradas personalizadas.
• Mensajes del sistema y del usuario: Proporciona tanto contexto del sistema como entrada del usuario para crear conversaciones dinámicas.
• Salida PDF: Guarda las respuestas de chat generadas en un archivo PDF estructurado para su uso posterior.
• Procesamiento asíncrono: Garantiza aplicaciones receptivas procesando las respuestas de chat de forma asíncrona.

Cifrar

El Documentize PDF Security for .NET es una herramienta poderosa diseñada para mejorar la seguridad de tus documentos PDF al proporcionar capacidades de cifrado, descifrado y firma. Garantiza que tu información sensible permanezca confidencial y protegida contra accesos no autorizados.

Cómo cifrar un PDF

Para cifrar un documento PDF, sigue estos pasos:

1. Crea una instancia de EncryptOptions con las contraseñas de usuario y propietario deseadas.
2. Agrega el archivo PDF de entrada usando el método AddInput.
3. Agrega el archivo PDF de salida usando el método AddOutput.
4. Ejecuta el cifrado mediante el método Encrypt de la clase PdfSecurity.

1// Create EncryptOptions object to set instructions
2var options = new EncryptOptions("123456", "qwerty");
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
7// Perform the process
8PdfSecurity.Encrypt(options);

Características clave:

• Cifrar documentos PDF: Protege tus archivos PDF añadiendo contraseñas de usuario y propietario.

• Automatización: Integra el cifrado y descifrado en tus aplicaciones .NET para flujos de trabajo automatizados.
• Cumplimiento: Asegura que tus documentos cumplan con los estándares industriales de seguridad documental.

Decrypt

El Documentize PDF Security for .NET es una herramienta poderosa diseñada para mejorar la seguridad de tus documentos PDF al proporcionar capacidades de cifrado, descifrado y firma. Garantiza que tu información sensible se mantenga confidencial y protegida contra accesos no autorizados.

Cómo descifrar un PDF

Para descifrar un documento PDF, sigue estos pasos:

1. Crea una instancia de DecryptionOptions con la contraseña necesaria.
2. Añade el archivo PDF de entrada usando el método AddInput.
3. Añade el archivo PDF de salida usando el método AddOutput.
4. Ejecuta el descifrado usando el método Decrypt de la clase PdfSecurity.

1// Create DecryptOptions object to set instructions
2var options = new DecryptOptions("123456");
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
7// Perform the process
8PdfSecurity.Decrypt(options);

Características clave:

• Descifrar documentos PDF: Elimina el cifrado de los PDFs cuando sea necesario.
• Automatización: Integra el cifrado y descifrado en tus aplicaciones .NET para flujos de trabajo automatizados.
• Cumplimiento: Asegura que tus documentos cumplan con los estándares de la industria en materia de seguridad documental.

Firma

El componente Documentize PDF Security for .NET permite a los usuarios firmar digitalmente documentos PDF. Ofrece un proceso simplificado para agregar firmas, garantizar la autenticidad y proteger el contenido del PDF. El componente admite firmas tanto visibles como invisibles y brinda opciones para personalizar la posición de la firma, el motivo, la información de contacto y más.

Cómo firmar documentos PDF

Para firmar un documento PDF usando un archivo PFX, sigue estos pasos:

1. Instanciar la clase SignOptions con la ruta del archivo PFX y la contraseña.
2. Agregar el PDF de entrada y el archivo de salida a las opciones.
3. Ejecutar el método Sign para aplicar la firma.

1// Create SignOptions object to set instructions
2var options = new SignOptions("path_to_your_pfx_file.pfx", "password_of_your_pfx_file");
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
7// Perform the process
8PdfSecurity.Sign(options);

Cómo utilizar un Stream para el archivo PFX

También puedes firmar un PDF usando un certificado PFX proporcionado como un stream en lugar de una ruta de archivo. Esto permite un manejo más flexible del almacenamiento del certificado.

1using var pfxStream = File.OpenRead(@"path_to_your_pfx_file.pfx");
2var options = new SignOptions(pfxStream, "password_of_your_pfx_file");
3options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
4options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
5// Perform the process
6PdfSecurity.Sign(options);

Cómo aplicar firmas invisibles

Para agregar una firma invisible (una que asegura el documento sin mostrar la firma en el mismo), simplemente establece la propiedad Visible en false.

1. Crear una instancia de SignOptions.
2. Establecer Visible en false.
3. Agregar los archivos de entrada y salida.
4. Llamar a Sign para aplicar la firma invisible.

1var options = new SignOptions("path_to_your_pfx_file.pfx", "password_of_your_pfx_file");
2options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
3options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
4// Configure invisible signature
5signOptions.Visible = false;
6// Perform the process
7PdfSecurity.Sign(options);

Cómo usar opciones extra para la firma de documentos PDF

Puedes usar opciones adicionales al agregar la firma a un archivo PFX, como Reason, Contact, Location, PageNumber.

1. Instanciar la clase SignOptions con la ruta del archivo PFX y la contraseña.
2. Agregar el PDF de entrada y el archivo de salida a las opciones.
3. Establecer valores para tus opciones.
4. Ejecutar el método Sign para aplicar la firma.

 1// Create SignOptions object to set instructions
 2var options = new SignOptions("path_to_your_pfx_file.pfx", "password_of_your_pfx_file");
 3// Add input file path
 4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 5// Set output file path
 6options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
 7// Optional parameters
 8options.Reason = "my Reason";
 9options.Contact = "my Contact";
10options.Location = "my Location";
11options.PageNumber = 3;
12// Perform the process
13PdfSecurity.Sign(options);

Cómo agregar una marca de tiempo a un PDF

Para agregar una marca de tiempo segura a un documento PDF, sigue estos pasos:

1. Crear una instancia de AddTimestampOptions para configurar el proceso de marcación de tiempo.
2. Agregar el archivo PDF de entrada usando el método AddInput.
3. Establecer la ruta del archivo de salida usando AddOutput.
4. Ejecutar la marcación de tiempo usando el método Sign.

1// Create SignOptions object to set instructions
2var options = new SignOptions("path_to_your_pfx_file.pfx", "password_for_your_pfx_file");
3options.TimestampOptions = new TimestampOptions("server_url");
4// Add input file path
5options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
6// Set output file path
7options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
8// Perform the process
9PdfSecurity.Sign(options);

Cómo usar autenticación personalizada con el servidor de marca de tiempo

Puedes proporcionar credenciales de autenticación básica al conectarte al servidor de marca de tiempo. Esto permite autenticarte con servidores que requieren un nombre de usuario y una contraseña.

1// Configure the timestamping options with authentication
2options.TimestampOptions = new TimestampOptions("timestamp_server_url", "username:password");

Características clave:

• Firmar digitalmente documentos PDF: Protege tus documentos con firmas digitales visibles o invisibles.
• Soporte PFX: Firma archivos PDF usando un certificado PFX.
• Opciones personalizables: Configura la firma con ajustes como motivo, ubicación y datos de contacto.
• Firmas visibles e invisibles: Elige si la firma será visible en el documento.
• Servidores de marca de tiempo personalizables: Usa URLs de servidores de marca de tiempo personalizados y credenciales de autenticación.

Aplanar Campos de Formulario

El Documentize PDF Form for .NET le permite convertir formularios PDF interactivos en documentos no editables, haciéndolos seguros contra modificaciones no autorizadas. Esta herramienta transforma los campos de formulario en contenido estático, mejorando la seguridad de sus documentos PDF. Es particularmente útil cuando necesita asegurar contratos, acuerdos o cualquier documento donde los campos del formulario deben permanecer sin cambios.

Cómo aplanar campos de formulario en un PDF

Para aplanar los campos de formulario en un documento PDF, siga estos pasos:

1. Cree una instancia de la clase FlattenFieldsOptions.
2. Añada los archivos de entrada y salida a las opciones.
3. Llame al método Flatten para realizar la operación de aplanado.

1// Create FlattenFieldsOptions object to set instructions
2var options = new FlattenFieldsOptions();
3// Add input file path
4options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
5// Set output file path
6options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
7// Perform the process
8PdfForm.Flatten(options);

Cómo obtener todos los campos en un PDF

Puede obtener información sobre cuántos campos contiene un documento.

1// Get Fields Names
2var fieldNames = PdfForm.GetNames(new GetFieldNamesOptions("path_to_your_pdf_file.pdf"));

Cómo aplanar todo excepto el primer campo en un PDF

Puede seleccionar aplanar solo campos de formulario específicos según criterios como la posición o el nombre del campo.

 1// Get Fields Names
 2var fieldNames = PdfForm.GetNames(new GetFieldNamesOptions("path_to_your_pdf_file.pdf"));
 3// Create FlattenFieldsOptions object to set instructions
 4var options = new FlattenFieldsOptions();
 5options.AddInput(new FileData("path_to_your_pdf_file.pdf"));
 6options.AddOutput(new FileData("path_to_result_pdf_file.pdf"));
 7// Skip 1 field.
 8options.SkipFields.Add(fieldNames[0]);
 9// Perform the process
10PdfForm.Flatten(options);

Características clave:

• Aplanar todos los campos de formulario: Convierte los campos de formulario interactivos en contenido estático no editable.
• Obtener nombres de los campos: Obtenga los nombres de los campos en un PDF.
• Aplanar campos seleccionados: Opcionalmente aplane campos específicos en un PDF mientras mantiene otros editables.