Accusoft Prizmdoc PDF Viewer Tutorial y Comparación

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.

Compara IronPDF con Accusoft PDF Viewer

• Convertir HTML a PDF
• Establecer encabezado y pie de página para PDF
• Convertir PDF en archivo de imagen
• Compare licencias, opciones de prueba gratuitas y mucho más

Visión general

Acerca de IronPDF

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.

Acerca de Accusoft PrizmDoc Viewer

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.

Cuadro comparativo

Instalemos los dos y comparemos el código.

Paso 1: Instalación

1. Instale la biblioteca IronPDF

Hay dos maneras de instalar IronPDF en su proyecto, sin que importe cuál adopte.

1.1. Descargar la DLL IronPDF

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.

1.2 Instalación mediante el gestor de paquetes NuGet

• 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 deGestor de paquetes NuGetluego busque IronPDF en la barra de búsqueda e instálelo.

  ---

Instale el Visor PrizmDoc de Accusoft

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.

Acceso al servidor PrizmDoc

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:

1. Autoalojado:

   Para esta opción, necesita organizar su servidor, y puedeDescargar PrizmDoc Server e instalarlo.Seguir leyendo 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.

2. **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 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 ypasar directamente a la comparación.

   Estructura de trabajo de Accusoft

   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.

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();
}

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();
}

Shared Sub Main(ByVal args() As String)
	'---Upload file to Server---
	Dim uploadResults As JObject = UploadToServer("myWebpage.html").Result
	Dim fileID As String = CStr(uploadResults.SelectToken("fileId"))
	Dim affinityToken As String = CStr(uploadResults.SelectToken("affinityToken"))

	'---Convert the uploaded file to PDF---
	Dim convertResults As JObject = Convert(affinityToken, fileID).Result
	Dim processId As String = CStr(convertResults.SelectToken("processId"))
	affinityToken = CStr(convertResults.SelectToken("affinityToken"))

	'---Check the status that conversion is completed---
	Dim convertStatusresults As JObject = ConvertStatus(processId, affinityToken).Result
	Dim convertStatus As String = CStr(convertResults.SelectToken("state"))

	'---Continuously checking whether conversion completed or not until completed---
	Do While Not (convertStatus.Equals("complete"))
		System.Threading.Thread.Sleep(30000)
		convertStatusresults = ConvertStatus(processId, affinityToken).Result
		convertStatus = CStr(convertStatusresults.SelectToken("state"))
	Loop

	'---Download the converted file from server---
	Dim newFileID As String = CStr(convertStatusresults.SelectToken("output.results [0].fileId"))
	DownloadFromServer(affinityToken, newFileID, "sample.pdf").Wait()

	Console.WriteLine("PDF file created successfully...!")
	Console.ReadKey()
End Sub

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);
        }
    }
}

Public Shared Async Function DownloadFromServer(ByVal affinityToken As String, ByVal fileId As String, ByVal outfile As String) As Task
	Dim endpoint = New Uri("https://api.accusoft.com/PCCIS/V1/WorkFile/" & fileId)

	Using client = New WebClient()
		client.Headers.Add("acs-api-key", ApiKey)
		client.Headers.Add("Accusoft-Affinity-Token", affinityToken)
		Dim output As New FileInfo(outfile)

		Using writeStream = output.Create()
			Dim results = Await client.DownloadDataTaskAsync(endpoint)
			Await writeStream.WriteAsync(results, 0, results.Length)
		End Using
	End Using
End Function

El ejemplo anterior requiere mucho esfuerzo! Para minimizar la carga de trabajo, Accusoft introdujo una biblioteca .NET denominadaAccusoft.PrizmDocServerSDKes una envoltura de la API REST del servidor PrizmDoc. Veamos cómo instalar y utilizar esta biblioteca en nuestro proyecto .NET

Instale el Accusoft.PrizmDocServerSDK

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;

  ---

Tutoriales prácticos

2. Comparación de códigos entre IronPDF y PrizmDoc Viewer

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.

3. Convertir HTML a PDF

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.

3.1. IronPDF HTML a 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
**/
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.

3.2. PrizmDoc Viewer HTML a PDF

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.

3.3. Comparación de códigos HTML a PDF

De estos ejemplos se desprende que IronPDF es un método más sencillo para crear archivos PDF y no requiere tanto tiempo.

4. Imagen a PDF

En esta comparación, tomamos un caso de uso en el que necesitamos crear un archivo PDF mediante el métodoImageny existe en nuestra carpeta debug del proyecto. Empecemos por IronPDF.

4.1. IronPDF Imagen a 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
**/
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.

4.2. PrizmDoc Viewer Imagen a 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");
}

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:

4.3. Comparación de códigos de imagen a PDF

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.

5. Fusionar archivos PDF

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.

5.1. IronPDF Fusionar archivos PDF

/**
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();
    }
}

'''
'''Merge PDF Files
'''anchor-ironpdf-merge-pdf-files
'''*
Imports IronPdf
Imports System.Collections.Generic
Shared Sub Main(ByVal args() As String)
	'create rendering converter  
	Dim Renderer = New IronPdf.ChromePdfRenderer()
	'create a list of pdf files
	Dim PDFs = New List(Of 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 PDF As PdfDocument = PdfDocument.Merge(PDFs)
		'save merged file to the target location
		PDF.SaveAs("sample.pdf")
	
'INSTANT VB NOTE: The variable pdf was renamed since Visual Basic will not allow local variables with the same name as parameters or other local variables:
		For Each .pdf_Conflict In PDFs
			.pdf_Conflict.Dispose()
		Next pdf_Conflict
	End Using
End Sub

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.

5.2. PrizmDoc Viewer Combinar archivos 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");
}

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");
}

Imports System.Threading.Tasks
Imports Accusoft.PrizmDocServer
Imports Accusoft.PrizmDocServer.Conversion

Shared Sub Main(ByVal args() As String)
	PdfMerge().GetAwaiter().GetResult()
End Sub
Private Shared Async Function PdfMerge() As Task
	'instantiate PrizmDocServerClient object
	Dim prizmDocServer = New PrizmDocServerClient("https://api.accusoft.com", "Your-API-KEY")
	'pass the list of pdf files to PrizmDoc Server
	Dim result As ConversionResult = Await prizmDocServer.CombineToPdfAsync({
		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")
End Function

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.

6. Encabezado y pie de página 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 Cabecera

• Nú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.

6.1. Encabezado y pie de página de PDF IronPDF

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():

• TextoCentro para imprimir el texto en el centro del Encabezado o Pie de Página.
• TextoIzquierdo para imprimir el texto a la izquierda del Encabezado o Pie de Página.
• TextoDerecho para imprimir el texto a la derecha del Encabezado o Pie de Página.
• DrawDividerLine dibuja una línea que separa el contenido de la página del Encabezado o Pie de Página.
• FontFamily para especificar la familia de fuentes del Encabezado o del Pie de página.
• FontSize para especificar el tamaño de la fuente del Encabezado o Pie de página.

• 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:

• {página} Imprime el número de página actual en el encabezado o en el pie de página.
• {total-páginas} imprime el número total de páginas en el Encabezado o Pie de página.
• {url} se utiliza para imprimir la URL de la página renderizada.
• {fecha} Imprime la fecha actual en el encabezado o en el pie de página.
• {tiempo} imprime la hora actual en el Encabezado o Pie de Página.
• {html-title} Imprime el título de la página web renderizada en el encabezado o en el pie de página.

• {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.

6.2. Encabezado y pie de página PDF de PrizmDoc Viewer

PrizmDoc Viewer proporciona la clase HeaderFooterOptions para tratar con el Encabezado y el Pie, con las siguientes propiedades:

• Líneas especifica la línea(s) para cabecera y pie de página(más claro cuando entienda el siguiente ejemplo)cada línea tiene las siguientes propiedades:

  • Izquierda imprime el texto a la izquierda de la línea de encabezado o pie de página.

  • Centro imprime el texto a la izquierda de la línea de Encabezado o Pie.
• Derecha imprime el texto a la derecha de la línea de encabezado o pie de página.
• FamiliaDeFuente para especificar la familia de fuente del texto del Encabezado o Pie de Página.
• FontSize para especificar el tamaño de la fuente del texto del Encabezado o Pie de página.

• 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:

6.3. Comparación de códigos de encabezado y pie de página de PDF

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.

7. Convertir páginas PDF en imágenes

Tomemos otro caso de uso: tenemos un archivo PDF sencillo llamado Sample_PDF.pdf que sólo tiene 2 páginas.

Página 1	Página 2

Y tenemos que crear una imagen de cada página. En primer lugar, veremos cómo realizar esta tarea utilizando IronPDF.

7.1. IronPDF Convertir PDF a imagen

/**
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:

Página1 Imagen	Página2 Imagen

Podemos ver lo sencillo que es crear una imagen de cada página PDF utilizando IronPDF. Ahora, realizaremos la misma tarea utilizando PrizmDoc Viewer.

7.2. PrizmDoc Viewer PDF a Imagen

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:

Página 1	Página 2

7.3. Comparación de códigos PDF a imagen

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.

8. Precios de las licencias

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.

8.1. Opciones de licencia de IronPDF

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.

• Para empresas con varias sedes, la licencia comienza a partir de 1199, $.
• Para los servicios SaaS, las licencias empiezan a partir de 1099, dólares.

• 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.

8.2. Opciones de licencia de PrizmDoc Viewer

Opción de autoalojamiento

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.

Opción basada en la nube

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.

Acceso rápido a tutoriales

Obtenga el Manual de inicio rápido de C# IronPDF

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ía

Explorar la referencia API de IronPDF

Explore 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 API