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 PDFs
• Convertir PDF a archivo de imagen
• Compare licencias, opciones de prueba gratuita y más

Visión general

Acerca de IronPDF

IronPDF es una biblioteca C# HTML a PDF. 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.

Puedes descargar un archivo del proyecto desde este enlace.

Acerca de Accusoft PrizmDoc Viewer

PrizmDoc Viewer es una API REST que se utiliza para trabajar con archivos PDF y convertirlos en 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 agregar su referencia a tu proyecto. Después de esto, puedes acceder fácilmente al espacio de nombres IronPdf de la siguiente manera:

using 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 está utilizando la GUI de NuGet Package Manager, busque IronPDF en la barra de búsqueda e instálelo.

  ---

  Instalar el PrizmDoc Viewer de Accusoft

  Hay dos partes de PrizmDoc Viewer, una 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.

  Accede 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 una solicitud (entrada) y convierte el documento a un archivo PDF, luego envía el archivo PDF convertido al cliente como una 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. Alojado por uno mismo:

   Para esta opción, necesitas organizar tu servidor y puedes Descargar PrizmDoc Server y luego instalarlo. Lee más sobre cómo instalar PrizmDoc Server en Windows.

   Nota: Se necesita un mínimo de 32 GB de RAM y un CPU de 4 núcleos, de lo contrario, puede tener una mala experiencia.

2. Alojado en la nube:

   Es un servicio basado en la nube de PrizmDoc Viewer y no necesitas configurar tu servidor. Lo utilizaremos para nuestra comparación. Para hacer esto, crea tu cuenta y luego se abrirá la página de inicio. Puedes copiar el API key desde el menú API Key, veremos más adelante cómo usarlo.

   Primero, veremos la estructura básica de cómo trabajar con PrizmDoc Viewer para convertir los documentos en un archivo PDF, y vamos a interactuar directamente con Accusoft server usando WebClient() en una aplicación de consola de C#.

   Nota: El siguiente ejemplo es solo para una comprensión conceptual de cómo PrizmDoc maneja archivos PDF. Es un poco largo, así que no hay problema si omites este ejemplo y pasas directamente a la comparación.

   Estructura de Trabajo Accusoft

   En este ejemplo, convertiremos el myWebpage.html al archivo sample.pdf.

Nota: Tenemos que instalar la biblioteca Newtonsoft y agregar 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 Clave API en ella de la siguiente manera:

static string ApiKey= "Your-API-KEY";

static string ApiKey= "Your-API-KEY";

IRON VB CONVERTER ERROR developers@ironsoftware.com

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 subido 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"
    }
  }
}

Verifique el estado para ver si la conversión está completada 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. Descargue el archivo convertido del 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 presentó una biblioteca .NET llamada Accusoft.PrizmDocServerSDK, que es un contenedor alrededor de la API REST de PrizmDoc Server. 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ás utilizando la interfaz gráfica del Administrador de Paquetes NuGet, navega por Accusoft.PrizmDocServerSDK en la barra de búsqueda e instálalo.

  Ahora, puedes acceder fácilmente al namespace Accusoft.PrizmDocServer y usarlo accediendo a:

  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, tomemos el caso de uso de que tenemos una página web llamada myWebPage.html y queremos crear un archivo PDF a partir de ella, 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 puedes especificar cualquier ruta como esta: PDF.SaveAs("E:/sample.pdf");

Leer más sobre cómo trabajar con IronPDF para gestionar 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 cómo obtener la Accusoft API Key, y ahora veremos cómo 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

Lea más 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 la Imagen, y 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 usando 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 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 página web simple 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 en el lado izquierdo del Encabezado,
• DateTime en el lado derecho del Encabezado

• Número de página de páginas totales

  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 Pie de página de un archivo PDF, IronPDF proporciona una propiedad en la clase ChromePdfRenderer llamada RenderingOptions, la cual se puede usar de la siguiente manera:

• Para Header:

  C# ChromePdfRenderer_Obj.RenderingOptions.TextHeader=new TextHeaderFooter()

• Para el pie de página:

  C# ChromePdfRenderer_Obj.RenderingOptions.TextFooter=new TextHeaderFooter()

  Podemos establecer las siguientes propiedades al inicializar TextHeaderFooter():

• CenterText para imprimir el texto en el centro del encabezado o pie de página.
• LeftText para imprimir el texto en el lado izquierdo del encabezado o pie de página.
• RightText para imprimir el texto en el lado derecho 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 pie de página.
• FontSize para especificar el tamaño de 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. Se puede escribir entre llaves { } de la siguiente manera:

• {page} imprime el número de página actual en el Encabezado o Pie de página.
• {total-pages} imprime el número total de páginas en el Encabezado o Pie de página.
• {url} se usaba para imprimir la URL de la página renderizada.
• {date} imprime la fecha actual en el Encabezado o Pie de página.
• {time} 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 pie de página

• {pdf-title} imprime el título del documento en el Encabezado o Pie de página.

  Leer más en detalle sobre cómo trabajar con el encabezado y el 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 manejar Heder y Footer, con las siguientes propiedades:

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

  • Left imprime el texto en el lado izquierdo de la línea del encabezado o pie de página.

  • Center imprime el texto en el lado izquierdo de la línea del encabezado o pie de página.
• Derecha imprime el texto en el lado derecho de la línea del Encabezado o Pie de página.
• FontFamily para especificar la familia de fuentes del texto del encabezado o pie de página.
• FontSize para especificar el tamaño de fuente del texto del encabezado o pie de página.

• Color para especificar el color del texto del encabezado o pie de página.

  Leer más sobre 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

Examinemos un caso de uso más: tenemos un archivo PDF simple llamado Sample_PDF.pdf que tiene solo 2 páginas.

Page1	Page2

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:

Page1 Image	Page2 Image

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:

Page1	Page2

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 desde $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 múltiples ubicaciones, la licencia comienza desde $1199.
• Para los servicios SaaS, las licencias comienzan desde $1099.

• Para la redistribución OEM libre de regalías, las licencias comienzan desde $1599.

  Nota: Todos los paquetes de licencia mencionados anteriormente vienen con 1 año de soporte y actualizaciones.

  Leer más sobre todos los paquetes de licencias proporcionados de IronPDF.

8.2. Opciones de licencia de PrizmDoc Viewer

Opción de autoalojamiento

Si gestionas tu propio servidor, entonces el precio de la licencia es 7,900 USD/Anualmente con soporte estándar.

Leer más sobre toda la información de los paquetes proporcionados 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 accedemos al servidor de PrizmDoc Viewer y obtenemos la salida (documento resultante).

Prepaid Buckets significa que paga una vez y obtiene las transacciones, las cuales 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