Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
Accusoft PDF Viewer proporciona capacidades de HTML a PDF y otras tareas de edición y manipulación de PDF para .NET. IronPDF también realiza estas mismas tareas mediante programación, ahorrándole tiempo y esfuerzo en sus proyectos C#.
Comparemos los dos y encontremos cuál es el mejor para su proyecto.
IronPDF es una biblioteca de conversión de HTML a PDF en C#. Permite a los ingenieros realizar tareas que incluyen la creación de archivos PDF a partir de fuentes como cadenas HTML, páginas Web, URL, así como la configuración de propiedades como marcas de agua, marcadores, encabezados y pies de página, etc. También podemos combinar varios archivos PDF en uno, o páginas PDF a imágenes, o viceversa.
Es gratuito para el desarrollo y ofrece una prueba de implantación de 30 días para poner en marcha su proyecto.
Puede descargar un proyecto de archivo desde aquí enlace.
Visor PrizmDoc es una API REST que se utiliza para trabajar con archivos PDF y convertirlos a otros formatos de forma remota. PrizmDoc puede convertir más de 100 formatos diferentes del archivo a PDF y PDF a PNG, JPG, TIFF y SVG. También puede utilizarse para incluir distintos tipos de opciones de firma electrónica en las aplicaciones.
IronPDF | Visor PrizmDoc |
---|---|
Trabaje con archivos PDF mediante programación. | Trabaje con archivos PDF mediante programación. |
Compatible con .NET core en Windows, Mac o Linux. | Compatible con .NET Core utilizando Windows, Mac o Linux. |
Obras locales | Envía documentos a un servidor remoto. |
Trabajar con o sin programación asíncrona. | Debe usar Programación Asíncrona usando `System.Threading.Tasks`. |
Trabaja fácilmente sin conexión una vez que instalemos IronPF en nuestro sistema. | Must connect with the internet to send the request to the Visor PrizmDoc server (Cloud-hosted or self-hosted). |
Ofrece numerosas funciones predefinidas. | Proporciona algunas funciones predefinidas. |
A menudo requiere un mínimo de líneas de código. | A menudo requiere muchas líneas de código. |
Conversiones ilimitadas por proyecto en cada plan de licencia. | Número limitado de transacciones en cada plan de licencias alojadas en la nube. |
Gratis para el desarrollo sin límite de tiempo. | Sólo 300 transacciones con prueba. |
Instalemos los dos y comparemos el código.
Hay dos maneras de instalar IronPDF en su proyecto, sin que importe cuál adopte.
Descargar IronPDF.dll y añada su referencia a su proyecto. Después de esto, puedes acceder fácilmente al espacio de nombres IronPdf
de la siguiente manera:
usando IronPdf;
Ahora, puede acceder fácilmente a las funciones y clases proporcionadas por IronPDF.
Consola del gestor de paquetes:
Si utiliza la consola del gestor de paquetes, ejecute el siguiente comando:
:ProductInstall
Gestionar paquetes para la solución:
Si utiliza la GUI de [Gestor de paquetes NuGet](https://www.nuget.org/packages/IronPdf)luego busque `IronPDF` en la barra de búsqueda e instálelo.
Hay dos partes de PrizmDoc Viewer, uno es el lado del servidor llamado PrizmDoc Server
que se comporta como una API Restful. El otro es nuestro proyecto, mediante el cual golpeamos esa API y obtenemos la respuesta.
Como vemos por su nombre, es una aplicación del lado del servidor que obtiene la información básica con el documento como petición (entrada) y convierte el documento en un archivo PDF, luego envía el archivo PDF convertido al cliente como respuesta (salida). Es el corazón técnico del producto, que es un motor de tratamiento y conversión de documentos. Podemos utilizarlo de dos formas distintas, sin que haya diferencia entre la que usted adopte porque ambas tienen la misma estructura y técnicas de programación:
Autoalojado:
Para esta opción, necesita organizar su servidor, y puede [Descargar PrizmDoc Server](https://www.accusoft.com/products/prizmdoc-suite/prizmdoc-viewer-trial/) e instalarlo.[Seguir leyendo](https://help.accusoft.com/PrizmDoc/v13.14/HTML/install-on-windows.html) sobre cómo instalar PrizmDoc Server en Windows.
**Nota:** Necesita un mínimo de 32 GB de Ram y 4 Core CPU, de lo contrario, puede enfrentarse a una mala experiencia.
**alojado en la nube
Es un servicio basado en la nube de PrizmDoc Viewer y no necesita disponer de su servidor. Lo utilizaremos para nuestra comparación. Para ello, [cree su cuenta](https://cloud.accusoft.com/signup) y se abrirá la página de inicio. Puedes copiar `API key` desde el menú `API Key`, veremos más adelante como utilizarlo.
En primer lugar, veremos la estructura básica de cómo trabajar con PrizmDoc Viewer para convertir los documentos en un archivo PDF, e interactuaremos directamente con el servidor de Accusoft
utilizando WebClient()
en C# Aplicación de Consola.
Nota: El siguiente ejemplo es sólo para una comprensión conceptual de cómo PrizmDoc maneja archivos PDF. Es un poco largo, así que no hay problema si te saltas este ejemplo y pasar directamente a la comparación.
En este ejemplo, convertiremos el archivo myWebpage.html
en el archivo sample.pdf
.
Nota: Tenemos que instalar la librería Newtonsoft
y añadir su referencia en el proyecto.
En primer lugar, añade las siguientes bibliotecas a tu proyecto:
using System;
using System.IO;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;//install Newtonsoft
using System;
using System.IO;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;//install Newtonsoft
Imports System
Imports System.IO
Imports System.Net
Imports System.Text
Imports System.Threading.Tasks
Imports Newtonsoft.Json.Linq 'install Newtonsoft
Luego crea una variable pública Accusoft API Key
y pega tu API Key en ella como sigue: ``` cadena estática ApiKey= "Tu-API-KEY";
Hay 3 pasos para tratar con archivos PDF utilizando PrizmDoc Viewer:
1. Cargue un archivo en el servidor PrizmDoc.
2. Convierte el archivo cargado.
3. Descargue el archivo convertido desde el servidor PrizmDoc.
Por lo tanto, haremos una función separada para cada paso.
```cs
static void Main(string [] args)
{
//---Upload file to Server---
JObject uploadResults = UploadToServer("myWebpage.html").Result;
string fileID = (string)uploadResults.SelectToken("fileId");
string affinityToken = (string)uploadResults.SelectToken("affinityToken");
//---Convert the uploaded file to PDF---
JObject convertResults = Convert(affinityToken, fileID).Result;
string processId = (string)convertResults.SelectToken("processId");
affinityToken = (string)convertResults.SelectToken("affinityToken");
//---Check the status that conversion is completed---
JObject convertStatusresults = ConvertStatus(processId, affinityToken).Result;
string convertStatus = (string)convertResults.SelectToken("state");
//---Continuously checking whether conversion completed or not until completed---
while (!(convertStatus.Equals("complete")))
{
System.Threading.Thread.Sleep(30000);
convertStatusresults = ConvertStatus(processId, affinityToken).Result;
convertStatus = (string)convertStatusresults.SelectToken("state");
}
//---Download the converted file from server---
string newFileID = (string)convertStatusresults.SelectToken("output.results [0].fileId");
DownloadFromServer(affinityToken, newFileID, "sample.pdf").Wait();
Console.WriteLine("PDF file created successfully...!");
Console.ReadKey();
}
1. Subir archivo al servidor:
public static async Task<JObject> UploadToServer(string fileToUpload)
{
FileInfo input = new FileInfo(fileToUpload);
if (input == null)
{
throw new ArgumentException("Missing parameter input", "input");
}
var fileName = input.Name;
var endpoint = new Uri("https://api.accusoft.com/PCCIS/V1/WorkFile");
using (var client = new WebClient())
{
client.Headers.Add("acs-api-key", ApiKey);
client.Headers.Add("Content-Type", "application/octet-stream");
using (var reader = new BinaryReader(input.OpenRead()))
{
var data = reader.ReadBytes((int)reader.BaseStream.Length);
var results = await client.UploadDataTaskAsync(endpoint, "POST", data);
string getResult = "";
getResult = Encoding.ASCII.GetString(results);
return JObject.Parse(getResult);
}
}
}
public static async Task<JObject> UploadToServer(string fileToUpload)
{
FileInfo input = new FileInfo(fileToUpload);
if (input == null)
{
throw new ArgumentException("Missing parameter input", "input");
}
var fileName = input.Name;
var endpoint = new Uri("https://api.accusoft.com/PCCIS/V1/WorkFile");
using (var client = new WebClient())
{
client.Headers.Add("acs-api-key", ApiKey);
client.Headers.Add("Content-Type", "application/octet-stream");
using (var reader = new BinaryReader(input.OpenRead()))
{
var data = reader.ReadBytes((int)reader.BaseStream.Length);
var results = await client.UploadDataTaskAsync(endpoint, "POST", data);
string getResult = "";
getResult = Encoding.ASCII.GetString(results);
return JObject.Parse(getResult);
}
}
}
Public Shared Async Function UploadToServer(ByVal fileToUpload As String) As Task(Of JObject)
Dim input As New FileInfo(fileToUpload)
If input Is Nothing Then
Throw New ArgumentException("Missing parameter input", "input")
End If
Dim fileName = input.Name
Dim endpoint = New Uri("https://api.accusoft.com/PCCIS/V1/WorkFile")
Using client = New WebClient()
client.Headers.Add("acs-api-key", ApiKey)
client.Headers.Add("Content-Type", "application/octet-stream")
Using reader = New BinaryReader(input.OpenRead())
Dim data = reader.ReadBytes(CInt(reader.BaseStream.Length))
Dim results = Await client.UploadDataTaskAsync(endpoint, "POST", data)
Dim getResult As String = ""
getResult = Encoding.ASCII.GetString(results)
Return JObject.Parse(getResult)
End Using
End Using
End Function
2. Convertir el archivo cargado a PDF:
public static async Task<JObject> Convert(string affinityToken, string fileID)
{
var endpoint = new Uri("https://api.accusoft.com/v2/contentConverters");
using (var client = new WebClient())
{
client.Headers.Add("Content-Type", "application/json");
client.Headers.Add("acs-api-key", ApiKey);
client.Headers.Add("Accusoft-Affinity-Token", affinityToken);
JObject myJson =
new JObject(
new JProperty("input",
new JObject(
new JProperty("sources",
new JArray(
new JObject(
new JProperty("fileId", fileID)
)
)
),
new JProperty("dest",
new JObject(
new JProperty("format", "pdf")
)
)
)
)
);
string results = await client.UploadStringTaskAsync(endpoint, "POST", myJson.ToString());
return JObject.Parse(results);
}
}
public static async Task<JObject> Convert(string affinityToken, string fileID)
{
var endpoint = new Uri("https://api.accusoft.com/v2/contentConverters");
using (var client = new WebClient())
{
client.Headers.Add("Content-Type", "application/json");
client.Headers.Add("acs-api-key", ApiKey);
client.Headers.Add("Accusoft-Affinity-Token", affinityToken);
JObject myJson =
new JObject(
new JProperty("input",
new JObject(
new JProperty("sources",
new JArray(
new JObject(
new JProperty("fileId", fileID)
)
)
),
new JProperty("dest",
new JObject(
new JProperty("format", "pdf")
)
)
)
)
);
string results = await client.UploadStringTaskAsync(endpoint, "POST", myJson.ToString());
return JObject.Parse(results);
}
}
Public Shared Async Function Convert(ByVal affinityToken As String, ByVal fileID As String) As Task(Of JObject)
Dim endpoint = New Uri("https://api.accusoft.com/v2/contentConverters")
Using client = New WebClient()
client.Headers.Add("Content-Type", "application/json")
client.Headers.Add("acs-api-key", ApiKey)
client.Headers.Add("Accusoft-Affinity-Token", affinityToken)
Dim myJson As New JObject(New JProperty("input", New JObject(New JProperty("sources", New JArray(New JObject(New JProperty("fileId", fileID)))), New JProperty("dest", New JObject(New JProperty("format", "pdf"))))))
Dim results As String = Await client.UploadStringTaskAsync(endpoint, "POST", myJson.ToString())
Return JObject.Parse(results)
End Using
End Function
El siguiente JSON es el valor resultante del objeto myJson
:
{
"input": {
"sources":
[
{"fileId": "Auto Generated FileId Value"}
],
"dest": {
"format": "pdf"
}
}
}
**Comprueba si la conversión se ha completado o no.
public static async Task<JObject> ConvertStatus(string processId, string affinityToken)
{
string endpoint = "https://api.accusoft.com/v2/contentConverters/" + processId;
using (var client = new WebClient())
{
client.BaseAddress = endpoint;
client.Headers.Add("acs-api-key", ApiKey);
client.Headers.Add("Accusoft-Affinity-Token", affinityToken);
string results = await client.DownloadStringTaskAsync(endpoint);
return JObject.Parse(results);
}
}
public static async Task<JObject> ConvertStatus(string processId, string affinityToken)
{
string endpoint = "https://api.accusoft.com/v2/contentConverters/" + processId;
using (var client = new WebClient())
{
client.BaseAddress = endpoint;
client.Headers.Add("acs-api-key", ApiKey);
client.Headers.Add("Accusoft-Affinity-Token", affinityToken);
string results = await client.DownloadStringTaskAsync(endpoint);
return JObject.Parse(results);
}
}
Public Shared Async Function ConvertStatus(ByVal processId As String, ByVal affinityToken As String) As Task(Of JObject)
Dim endpoint As String = "https://api.accusoft.com/v2/contentConverters/" & processId
Using client = New WebClient()
client.BaseAddress = endpoint
client.Headers.Add("acs-api-key", ApiKey)
client.Headers.Add("Accusoft-Affinity-Token", affinityToken)
Dim results As String = Await client.DownloadStringTaskAsync(endpoint)
Return JObject.Parse(results)
End Using
End Function
3. Descargar el archivo convertido desde el servidor
public static async Task DownloadFromServer(string affinityToken, string fileId, string outfile)
{
var endpoint = new Uri("https://api.accusoft.com/PCCIS/V1/WorkFile/" + fileId);
using (var client = new WebClient())
{
client.Headers.Add("acs-api-key", ApiKey);
client.Headers.Add("Accusoft-Affinity-Token", affinityToken);
FileInfo output = new FileInfo(outfile);
using (var writeStream = output.Create())
{
var results = await client.DownloadDataTaskAsync(endpoint);
await writeStream.WriteAsync(results, 0, results.Length);
}
}
}
public static async Task DownloadFromServer(string affinityToken, string fileId, string outfile)
{
var endpoint = new Uri("https://api.accusoft.com/PCCIS/V1/WorkFile/" + fileId);
using (var client = new WebClient())
{
client.Headers.Add("acs-api-key", ApiKey);
client.Headers.Add("Accusoft-Affinity-Token", affinityToken);
FileInfo output = new FileInfo(outfile);
using (var writeStream = output.Create())
{
var results = await client.DownloadDataTaskAsync(endpoint);
await writeStream.WriteAsync(results, 0, results.Length);
}
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
El ejemplo anterior requiere mucho esfuerzo! Para minimizar la carga de trabajo, Accusoft introdujo una biblioteca .NET denominada Accusoft.PrizmDocServerSDKes una envoltura de la API REST del servidor PrizmDoc. Veamos cómo instalar y utilizar esta biblioteca en nuestro proyecto .NET
Hay dos formas de instalar la envoltura.
Consola del gestor de paquetes:
Si utiliza la consola del gestor de paquetes, ejecute el siguiente comando:
:InstallCmd install-package Accusoft.PrizmDocServerSDK
Gestionar paquetes para la solución:
Si está utilizando la interfaz gráfica de NuGet Package Manager, busque `Accusoft.PrizmDocServerSDK` en la barra de búsqueda e instálelo.
Ahora, puede acceder fácilmente al espacio de nombres Accusoft.PrizmDocServer
y utilizarlo accediendo:
using Accusoft.PrizmDocServer;
Después de leer la introducción y la instalación de ambos componentes, ahora es el momento de trabajar con ellos. Para ello, tomaremos algunos casos de uso y los implementaremos utilizando ambos componentes. Esperamos que esto le permita comprender fácilmente ambas estructuras de programación y concluir cuál es la mejor para su proyecto.
En nuestra primera comparación, vamos a tomar el caso de uso que tenemos una página web llamada myWebPage.html
y queremos crear un archivo PDF a partir de ella, y luego guardarlo en la ubicación de destino.
/**
HTML to PDF
anchor-ironpdf-html-to-pdf
**/
using IronPdf;
static void Main(string [] args)
{
//create rendering converter
var converter = new ChromePdfRenderer();
//render html file to pdf
using var PDF = converter.RenderHTMLFileAsPdf("myWebPage.html");
//save to target location
PDF.SaveAs("sample.pdf");
}
/**
HTML to PDF
anchor-ironpdf-html-to-pdf
**/
using IronPdf;
static void Main(string [] args)
{
//create rendering converter
var converter = new ChromePdfRenderer();
//render html file to pdf
using var PDF = converter.RenderHTMLFileAsPdf("myWebPage.html");
//save to target location
PDF.SaveAs("sample.pdf");
}
'''
'''HTML to PDF
'''anchor-ironpdf-html-to-pdf
'''*
Imports IronPdf
Shared Sub Main(ByVal args() As String)
'create rendering converter
Dim converter = New ChromePdfRenderer()
'render html file to pdf
Dim PDF = converter.RenderHTMLFileAsPdf("myWebPage.html")
'save to target location
PDF.SaveAs("sample.pdf")
End Sub
El código anterior creará un archivo sample.pdf
y lo guardará en la carpeta bin>debug
del proyecto.
También puede especificar cualquier ruta como esta PDF.SaveAs("E:/muestra.pdf");
Seguir leyendo sobre cómo trabajar con IronPDF para tratar archivos PDF.
Ahora, haremos la misma tarea utilizando el Visor PrizmDoc, para que nuestra comparación resulte sencilla.
En la instalación de PrizmDoc Viewer, ya discutimos como obtener la Accusoft API Key
, y ahora veremos como usarla.
En primer lugar, enviamos una solicitud al servidor PrizmDoc y obtenemos una respuesta del mismo. Este proceso llevará algún tiempo, por lo que necesitamos utilizar la Programación Asíncrona.
Nota: Asegúrese de que su sistema está conectado a Internet mientras crea archivos PDF utilizando los servicios en la nube de PrizmDoc Viewer.
using Accusoft.PrizmDocServer;
using Accusoft.PrizmDocServer.Conversion;
static void Main(string [] args)
{
ChromePdfRenderer().GetAwaiter().GetResult();
}
private static async Task ChromePdfRenderer()
{
//instantiate PrizmDocServerClient object
var prizmDocServer = new PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY");
// specify HTML file and convert it to a PDF.
ConversionResult result = await prizmDocServer.ConvertToPdfAsync("myWebPage.html");
// Save pdf file to the target location
await result.RemoteWorkFile.SaveAsync("sample.pdf");
}
using Accusoft.PrizmDocServer;
using Accusoft.PrizmDocServer.Conversion;
static void Main(string [] args)
{
ChromePdfRenderer().GetAwaiter().GetResult();
}
private static async Task ChromePdfRenderer()
{
//instantiate PrizmDocServerClient object
var prizmDocServer = new PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY");
// specify HTML file and convert it to a PDF.
ConversionResult result = await prizmDocServer.ConvertToPdfAsync("myWebPage.html");
// Save pdf file to the target location
await result.RemoteWorkFile.SaveAsync("sample.pdf");
}
Imports Accusoft.PrizmDocServer
Imports Accusoft.PrizmDocServer.Conversion
Shared Sub Main(ByVal args() As String)
ChromePdfRenderer().GetAwaiter().GetResult()
End Sub
Private Shared Async Function ChromePdfRenderer() As Task
'instantiate PrizmDocServerClient object
Dim prizmDocServer = New PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY")
' specify HTML file and convert it to a PDF.
Dim result As ConversionResult = Await prizmDocServer.ConvertToPdfAsync("myWebPage.html")
' Save pdf file to the target location
Await result.RemoteWorkFile.SaveAsync("sample.pdf")
End Function
Seguir leyendo sobre cómo trabajar con PrizmDoc Viewer.
De estos ejemplos se desprende que IronPDF es un método más sencillo para crear archivos PDF y no requiere tanto tiempo.
En esta comparación, tomamos un caso de uso en el que necesitamos crear un archivo PDF mediante el método Imageny existe en nuestra carpeta debug
del proyecto. Empecemos por IronPDF.
/**
Image to PDF
anchor-ironpdf-image-to-pdf
**/
using IronPdf;
static void Main(string [] args)
{
//specify the image to be convert
using var converted = ImageToPdfConverter.ImageToPdf("google.png");
//save PDF file to the target location
converted.SaveAs("sample.pdf");
}
/**
Image to PDF
anchor-ironpdf-image-to-pdf
**/
using IronPdf;
static void Main(string [] args)
{
//specify the image to be convert
using var converted = ImageToPdfConverter.ImageToPdf("google.png");
//save PDF file to the target location
converted.SaveAs("sample.pdf");
}
'''
'''Image to PDF
'''anchor-ironpdf-image-to-pdf
'''*
Imports IronPdf
Shared Sub Main(ByVal args() As String)
'specify the image to be convert
Dim converted = ImageToPdfConverter.ImageToPdf("google.png")
'save PDF file to the target location
converted.SaveAs("sample.pdf")
End Sub
Salida:
Esta captura de pantalla es de un archivo PDF recién creado sample.pdf
utilizando el código anterior:
Podemos ver lo fácil que es crear un archivo PDF a partir de una imagen utilizando IronPDF. Ahora, vamos a hacer la misma tarea utilizando PrizmDoc Viewer y ver su archivo PDF generado.
static void Main(string [] args)
{
ImageToPDF().GetAwaiter().GetResult();
}
private static async Task ImageToPDF()
{
//instantiate PrizmDocServerClient object
var prizmDocServer = new PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY");
//specify the image to be convert
ConversionResult results = await prizmDocServer.ConvertToPdfAsync("google.png");
//save pdf file to the target location
await results.RemoteWorkFile.SaveAsync("sample.pdf");
}
static void Main(string [] args)
{
ImageToPDF().GetAwaiter().GetResult();
}
private static async Task ImageToPDF()
{
//instantiate PrizmDocServerClient object
var prizmDocServer = new PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY");
//specify the image to be convert
ConversionResult results = await prizmDocServer.ConvertToPdfAsync("google.png");
//save pdf file to the target location
await results.RemoteWorkFile.SaveAsync("sample.pdf");
}
Shared Sub Main(ByVal args() As String)
ImageToPDF().GetAwaiter().GetResult()
End Sub
Private Shared Async Function ImageToPDF() As Task
'instantiate PrizmDocServerClient object
Dim prizmDocServer = New PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY")
'specify the image to be convert
Dim results As ConversionResult = Await prizmDocServer.ConvertToPdfAsync("google.png")
'save pdf file to the target location
Await results.RemoteWorkFile.SaveAsync("sample.pdf")
End Function
Salida: Esta captura de pantalla es de un archivo PDF recién creado sample.pdf
a partir del código anterior:
Podemos ver que sólo necesitamos escribir 2 simples líneas de código utilizando IronPDF. Por otro lado, utilizando el servidor PrizmDoc, tenemos que escribir muchas líneas de código con Programación Asíncrona. La salida de IronPDF también proporciona automáticamente un documento utilizable a página completa.
En esta comparación, supongamos que tenemos tres archivos PDF llamados A.pdf
, B.pdf
y C.pdf
. Queremos fusionarlos en un solo archivo PDF, y podemos realizar esta tarea utilizando ambos componentes. En primer lugar, veremos cómo realizar esta tarea utilizando IronPDF.
/**
Merge PDF Files
anchor-ironpdf-merge-pdf-files
**/
using IronPdf;
using System.Collections.Generic;
static void Main(string [] args)
{
//create rendering converter
var Renderer = new IronPdf.ChromePdfRenderer();
//create a list of pdf files
var PDFs = new List<PdfDocument>();
PDFs.Add(PdfDocument.FromFile("A.pdf"));
PDFs.Add(PdfDocument.FromFile("B.pdf"));
PDFs.Add(PdfDocument.FromFile("C.pdf"));
//merge the list of pdf file
using PdfDocument PDF = PdfDocument.Merge(PDFs);
//save merged file to the target location
PDF.SaveAs("sample.pdf");
foreach(var pdf in PDFs){
pdf.Dispose();
}
}
/**
Merge PDF Files
anchor-ironpdf-merge-pdf-files
**/
using IronPdf;
using System.Collections.Generic;
static void Main(string [] args)
{
//create rendering converter
var Renderer = new IronPdf.ChromePdfRenderer();
//create a list of pdf files
var PDFs = new List<PdfDocument>();
PDFs.Add(PdfDocument.FromFile("A.pdf"));
PDFs.Add(PdfDocument.FromFile("B.pdf"));
PDFs.Add(PdfDocument.FromFile("C.pdf"));
//merge the list of pdf file
using PdfDocument PDF = PdfDocument.Merge(PDFs);
//save merged file to the target location
PDF.SaveAs("sample.pdf");
foreach(var pdf in PDFs){
pdf.Dispose();
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
El código anterior creará un archivo sample.pdf
, que es la combinación de A.pdf
, B.pdf
y C.pdf
.
Ahora, realizaremos la misma tarea utilizando PrizmDoc Viewer.
using System.Threading.Tasks;
using Accusoft.PrizmDocServer;
using Accusoft.PrizmDocServer.Conversion;
static void Main(string [] args)
{
PdfMerge().GetAwaiter().GetResult();
}
private static async Task PdfMerge()
{
//instantiate PrizmDocServerClient object
var prizmDocServer = new PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY");
//pass the list of pdf files to PrizmDoc Server
ConversionResult result = await prizmDocServer.CombineToPdfAsync(
new []{
new ConversionSourceDocument("A.pdf"),
new ConversionSourceDocument("B.pdf"),
new ConversionSourceDocument("C.pdf"),
});
//save merged file to the target location
await result.RemoteWorkFile.SaveAsync("sample.pdf");
}
using System.Threading.Tasks;
using Accusoft.PrizmDocServer;
using Accusoft.PrizmDocServer.Conversion;
static void Main(string [] args)
{
PdfMerge().GetAwaiter().GetResult();
}
private static async Task PdfMerge()
{
//instantiate PrizmDocServerClient object
var prizmDocServer = new PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY");
//pass the list of pdf files to PrizmDoc Server
ConversionResult result = await prizmDocServer.CombineToPdfAsync(
new []{
new ConversionSourceDocument("A.pdf"),
new ConversionSourceDocument("B.pdf"),
new ConversionSourceDocument("C.pdf"),
});
//save merged file to the target location
await result.RemoteWorkFile.SaveAsync("sample.pdf");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
El código anterior también creará un archivo sample.pdf
, que es la combinación de los archivos A.pdf
, B.pdf
y C.pdf
.
En esta comparación, supongamos que tenemos una simple página Web llamada myWebPage.html
que tiene el siguiente HTML y CSS:
<html>
<head>
<style>
li {
font-size:x-large;
color: rgba(156, 89, 13, 0.897);
list-style:square;
}
</style>
</head>
<body>
<h1 style="text-align: center;">Hello World..!</h1>
<h1>Main Menu</h1>
<ul>
<li>SubMenu 1</li>
<li>SubMenu 2</li>
<li>SubMenu 3</li>
<li>SubMenu 4</li>
<li>SubMenu 5</li>
</ul>
</body>
</html>
<html>
<head>
<style>
li {
font-size:x-large;
color: rgba(156, 89, 13, 0.897);
list-style:square;
}
</style>
</head>
<body>
<h1 style="text-align: center;">Hello World..!</h1>
<h1>Main Menu</h1>
<ul>
<li>SubMenu 1</li>
<li>SubMenu 2</li>
<li>SubMenu 3</li>
<li>SubMenu 4</li>
<li>SubMenu 5</li>
</ul>
</body>
</html>
Queremos convertir esta Página Web en un archivo PDF, estableciendo las siguientes propiedades de Encabezado y Pie de Página:
Título de la página
a la izquierda de la cabecera,DateTime
a la derecha de la CabeceraNúmero total de páginas
a la derecha del pie de página.
En primer lugar, veremos cómo trabajar con IronPDF para establecer el Encabezado y el Pie de página.
Para manejar el encabezado y el pie de página de un archivo PDF, IronPDF proporciona una propiedad en la clase ChromePdfRenderer
llamada RenderingOptions
que se puede utilizar de la siguiente manera:
Para Header: C# ChromePdfRenderer_Obj.RenderingOptions.TextHeader=nuevo TextHeaderFooter()
**Para el pie de página C# ChromePdfRenderer_Obj.RenderingOptions.TextFooter=nuevo TextHeaderFooter()
Podemos establecer las siguientes propiedades al inicializar TextHeaderFooter()
:
Espaciado ajusta el espacio entre el contenido de la página y el Encabezado o Pie de Página.
Algunos de los siguientes atributos predefinidos son muy útiles para establecer el contenido del encabezado o pie de página. Puede escribirse entre llaves { }
como sigue:
{título pdf} imprime el título del documento en el Encabezado o Pie de página.
Seguir leyendo en detalle sobre cómo trabajar con Encabezado y Pie de Página utilizando IronPDF.
Veamos el siguiente ejemplo para implementar el caso de uso y demostrar cómo utilizar las propiedades anteriores para establecer el Encabezado y el Pie de página de un archivo PDF.
/**
Set Header and Footer
anchor-ironpdf-pdf-header-and-footer
**/
using IronPdf;
static void Main(string [] args)
{
//create rendering converter
var converter = new ChromePdfRenderer();
//setting Header properties
converter.RenderingOptions.TextHeader = new TextHeaderFooter()
{
DrawDividerLine = true,
LeftText = "Page Title",
RightText = "{date} {time}",
FontSize = 13
};
//setting footer properties
converter.RenderingOptions.TextFooter = new TextHeaderFooter()
{
RightText = "Page {page} of {total-pages}",
FontSize = 12
};
//specify the file to be converted
using var PDF = converter.RenderHTMLFileAsPdf("myWebPage.html");
//save to target location
PDF.SaveAs("sample.pdf");
}
/**
Set Header and Footer
anchor-ironpdf-pdf-header-and-footer
**/
using IronPdf;
static void Main(string [] args)
{
//create rendering converter
var converter = new ChromePdfRenderer();
//setting Header properties
converter.RenderingOptions.TextHeader = new TextHeaderFooter()
{
DrawDividerLine = true,
LeftText = "Page Title",
RightText = "{date} {time}",
FontSize = 13
};
//setting footer properties
converter.RenderingOptions.TextFooter = new TextHeaderFooter()
{
RightText = "Page {page} of {total-pages}",
FontSize = 12
};
//specify the file to be converted
using var PDF = converter.RenderHTMLFileAsPdf("myWebPage.html");
//save to target location
PDF.SaveAs("sample.pdf");
}
'''
'''Set Header and Footer
'''anchor-ironpdf-pdf-header-and-footer
'''*
Imports IronPdf
Shared Sub Main(ByVal args() As String)
'create rendering converter
Dim converter = New ChromePdfRenderer()
'setting Header properties
converter.RenderingOptions.TextHeader = New TextHeaderFooter() With {
.DrawDividerLine = True,
.LeftText = "Page Title",
.RightText = "{date} {time}",
.FontSize = 13
}
'setting footer properties
converter.RenderingOptions.TextFooter = New TextHeaderFooter() With {
.RightText = "Page {page} of {total-pages}",
.FontSize = 12
}
'specify the file to be converted
Dim PDF = converter.RenderHTMLFileAsPdf("myWebPage.html")
'save to target location
PDF.SaveAs("sample.pdf")
End Sub
Salida: La captura de pantalla del archivo PDF recién creado sample.pdf
por el código anterior:
Podemos ver lo sencillo que es trabajar con el Encabezado y el Pie de Página utilizando un lenguaje intuitivo mientras creamos un archivo PDF utilizando IronPDF. Ahora, vamos a ver cómo utilizar PrizmDoc Viewer para establecer Encabezado y Pie de página.
PrizmDoc Viewer proporciona la clase HeaderFooterOptions
para tratar con el Encabezado y el Pie, con las siguientes propiedades:
Color para especificar el color del texto del encabezado o pie de página.
Seguir leyendo acerca de cómo establecer el encabezado y pie de página de una página PDF utilizando el servidor PrizmDoc.
Veamos cómo implementar nuestro caso de uso utilizando las propiedades anteriores.
using System.Threading.Tasks;
using System.Collections.Generic;
using Accusoft.PrizmDocServer;
using Accusoft.PrizmDocServer.Conversion;
static void Main(string [] args)
{
SetHeaderFooter().GetAwaiter().GetResult();
}
private static async Task SetHeaderFooter()
{
//instantiate PrizmDocServerClient object with Header and footer properties
var prizmDocServer = new PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY");
ConversionResult result = await prizmDocServer.ConvertToPdfAsync(
"myWebPage.html",
header: new HeaderFooterOptions
{
Lines = new List<HeaderFooterLine>
{
new HeaderFooterLine { Left = "Page Title", Right = DateTime.Now.ToString() }
},
},
footer: new HeaderFooterOptions
{
Lines = new List<HeaderFooterLine>
{
new HeaderFooterLine { Right = "Page {{pageNumber}} of {{pageCount}}" },
},
});
//save to the target location
await result.RemoteWorkFile.SaveAsync("sample.pdf");
}
using System.Threading.Tasks;
using System.Collections.Generic;
using Accusoft.PrizmDocServer;
using Accusoft.PrizmDocServer.Conversion;
static void Main(string [] args)
{
SetHeaderFooter().GetAwaiter().GetResult();
}
private static async Task SetHeaderFooter()
{
//instantiate PrizmDocServerClient object with Header and footer properties
var prizmDocServer = new PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY");
ConversionResult result = await prizmDocServer.ConvertToPdfAsync(
"myWebPage.html",
header: new HeaderFooterOptions
{
Lines = new List<HeaderFooterLine>
{
new HeaderFooterLine { Left = "Page Title", Right = DateTime.Now.ToString() }
},
},
footer: new HeaderFooterOptions
{
Lines = new List<HeaderFooterLine>
{
new HeaderFooterLine { Right = "Page {{pageNumber}} of {{pageCount}}" },
},
});
//save to the target location
await result.RemoteWorkFile.SaveAsync("sample.pdf");
}
Imports System.Threading.Tasks
Imports System.Collections.Generic
Imports Accusoft.PrizmDocServer
Imports Accusoft.PrizmDocServer.Conversion
Shared Sub Main(ByVal args() As String)
SetHeaderFooter().GetAwaiter().GetResult()
End Sub
Private Shared Async Function SetHeaderFooter() As Task
'instantiate PrizmDocServerClient object with Header and footer properties
Dim prizmDocServer = New PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY")
Dim result As ConversionResult = Await prizmDocServer.ConvertToPdfAsync("myWebPage.html", header:= New HeaderFooterOptions With {.Lines = New List(Of HeaderFooterLine) _
From {
New HeaderFooterLine With {
.Left = "Page Title",
.Right = DateTime.Now.ToString()
}
}
},
footer:= New HeaderFooterOptions With {
.Lines = New List(Of HeaderFooterLine) From {
New HeaderFooterLine With {.Right = "Page {{pageNumber}} of {{pageCount}}"}
}
})
'save to the target location
Await result.RemoteWorkFile.SaveAsync("sample.pdf")
End Function
Salida:
La captura de pantalla del archivo PDF recién creado por el código anterior:
Podemos ver que IronPDF proporciona más funciones para establecer las propiedades de Encabezado y Pie de Página con una estructura de programación simple en comparación con PrizmDoc Viewer. También se sugiere que el archivo PDF generado por IronPDF es más legible y atractivo que el archivo generado por PrizmDoc Viewer.
Tomemos otro caso de uso: tenemos un archivo PDF sencillo llamado Sample_PDF.pdf
que sólo tiene 2 páginas.
Y tenemos que crear una imagen de cada página. En primer lugar, veremos cómo realizar esta tarea utilizando IronPDF.
/**
PDF to Image
anchor-ironpdf-convert-pdf-to-image
**/
using IronPdf;
static void Main(string [] args)
{
//specify file to be converted
var pdf = PdfDocument.FromFile("Sample_PDF.pdf");
//save images to the target location
pdf.RasterizeToImageFiles("image_*.png");
}
/**
PDF to Image
anchor-ironpdf-convert-pdf-to-image
**/
using IronPdf;
static void Main(string [] args)
{
//specify file to be converted
var pdf = PdfDocument.FromFile("Sample_PDF.pdf");
//save images to the target location
pdf.RasterizeToImageFiles("image_*.png");
}
'''
'''PDF to Image
'''anchor-ironpdf-convert-pdf-to-image
'''*
Imports IronPdf
Shared Sub Main(ByVal args() As String)
'specify file to be converted
Dim pdf = PdfDocument.FromFile("Sample_PDF.pdf")
'save images to the target location
pdf.RasterizeToImageFiles("image_*.png")
End Sub
Salida:
El código anterior creará las siguientes dos imágenes .png
:
Podemos ver lo sencillo que es crear una imagen de cada página PDF utilizando IronPDF. Ahora, realizaremos la misma tarea utilizando PrizmDoc Viewer.
using System.Linq;
using System.Collections.Generic;
using System.Threading.Tasks;
using Accusoft.PrizmDocServer;
using Accusoft.PrizmDocServer.Conversion;
static void Main(string [] args)
{
PdfToImage().GetAwaiter().GetResult();
}
private static async Task PdfToImage()
{
//instantiate PrizmDocServerClient object
var prizmDocServer = new PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY");
//convert PDF file to images
IEnumerable<ConversionResult> results = await PrizmDocServer.ConvertAsync("Sample_PDF.pdf", DestinationFileFormat.Png);
//Save each image.
for (int i = 0; i < results.Count(); i++)
{
await results.ElementAt(i).RemoteWorkFile.SaveAsync($"page-{i + 1}.png");
}
}
using System.Linq;
using System.Collections.Generic;
using System.Threading.Tasks;
using Accusoft.PrizmDocServer;
using Accusoft.PrizmDocServer.Conversion;
static void Main(string [] args)
{
PdfToImage().GetAwaiter().GetResult();
}
private static async Task PdfToImage()
{
//instantiate PrizmDocServerClient object
var prizmDocServer = new PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY");
//convert PDF file to images
IEnumerable<ConversionResult> results = await PrizmDocServer.ConvertAsync("Sample_PDF.pdf", DestinationFileFormat.Png);
//Save each image.
for (int i = 0; i < results.Count(); i++)
{
await results.ElementAt(i).RemoteWorkFile.SaveAsync($"page-{i + 1}.png");
}
}
Imports System.Linq
Imports System.Collections.Generic
Imports System.Threading.Tasks
Imports Accusoft.PrizmDocServer
Imports Accusoft.PrizmDocServer.Conversion
Shared Sub Main(ByVal args() As String)
PdfToImage().GetAwaiter().GetResult()
End Sub
Private Shared Async Function PdfToImage() As Task
'instantiate PrizmDocServerClient object
Dim prizmDocServer = New PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY")
'convert PDF file to images
Dim results As IEnumerable(Of ConversionResult) = Await PrizmDocServer.ConvertAsync("Sample_PDF.pdf", DestinationFileFormat.Png)
'Save each image.
For i As Integer = 0 To results.Count() - 1
Await results.ElementAt(i).RemoteWorkFile.SaveAsync($"page-{i + 1}.png")
Next i
End Function
Salida:
El código anterior también creará las siguientes dos imágenes .png
:
En comparación con PrizmDoc Viewer, utilizando IronPDF podemos crear fácilmente la imagen de cada página con el menor número de líneas de código, incluso sin iterar las páginas.
En las comparaciones anteriores, vemos la estructura técnica de trabajo y las funciones previstas de ambos componentes. Ahora veremos el precio de las licencias de ambos componentes. Es muy importante porque siempre nos esforzamos al máximo por cumplir nuestros requisitos con el mínimo presupuesto.
La licencia de IronPDF comienza a partir de $749 para un solo proyecto con un desarrollador.
Si eres ingeniero en una empresa o una agencia que proporciona trabajo a varios clientes, las licencias empiezan en 699 $ y pueden ajustarse en función del tamaño del equipo y el número de proyectos.
La siguiente licencia requiere un único pago.
Número de desarrolladores | Precio |
---|---|
1-5 | $699 |
6-10 | $799 |
11-20 | $899 |
21-50 | $999 |
Unlimited | $1,199 |
Para la redistribución OEM libre de derechos, las licencias empiezan a partir de 1599, dólares.
Nota: Todos los paquetes de licencia anteriores incluyen 1 año de soporte y actualizaciones.
Seguir leyendo sobre todos los paquetes de licencias de IronPDF.
Si gestiona su propio servidor, el precio de la licencia es de 7.900$/Anuales con soporte estándar.
Seguir leyendo sobre todos los paquetes de información de PrizmDoc Viewer.
Esta licencia corresponde a los servicios basados en la nube de PrizmDoc Viewer, que se escalan en función del número de transacciones.
**Terminologías
Transaction
significa que golpeamos el servidor PrizmDoc Viewer y obtenemos la salida (documento resultante).
Prepaid Buckets
significa que pagas una vez y obtienes las transacciones, que no caducan.
Número de transacciones | Cubos de prepago | Mensualmente | Anualmente |
---|---|---|---|
200 | $18 | ||
1,000 | $89 | ||
2,000 | $119 | ||
6,000 | $254 | $169 | 1.859 $ (6.000 transacciones/mes) |
12,000 | $434 | $289 | 3.179 $ (12.000 transacciones/mes) |
25,000 | $749 | $749 | 5.459 $ (25.000 transacciones/mes) |
50,000 | $1,199 | $799 | 8.789 $ (50.000 transacciones/mes) |
100,000 | $1,499 | $999 | 10.989 $ (100.000 transacciones/mes) |
200,000 | $2,549 | $1,699 | 19.188 $ (200.000 transacciones/mes) |
300,000 | $3,299 | $2,199 | 25.188 $ (300.000 transacciones/mes) |
400,000 | $4,049 | $2,699 | 31.188 $ (400.000 transacciones/mes) |
500,000 | $4,799 | $3,199 | 37.188 $ (500.000 transacciones/mes) |
Hemos creado una guía de recursos PDF gratuita para facilitar el desarrollo de archivos PDF en .NET, con guías de funciones y ejemplos comunes para manipular, editar, generar y guardar archivos PDF en C# y VB.NET para su proyecto.
Descargar la GuíaExplore la Referencia de la API para la Biblioteca IronPDF C#, incluyendo detalles de todas las características, clases, campos de métodos, espacios de nombres y enums de IronPDF.
Ver la referencia de la API9 productos API .NET para sus documentos de oficina