Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Comparaciones de productos
  4. Comparar con el Visualizador PDF de Accusoft
COMPARACIONES DE PRODUCTOS

Tutorial y Comparación de Visor de PDF de Accusoft Prizmdoc

Curtis Chau
Curtis Chau
Actualizado:

El Visor PDF de Accusoft 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 de manera programática, ahorrándole tiempo y esfuerzo en sus proyectos de C#.

Comparemos los dos y encontremos lo que es mejor para su proyecto.

Comparar IronPDF con Accusoft PDF Viewer

  • Convertir HTML a PDF
  • Establecer encabezado y pie de página para PDFs
  • Convertir PDF en archivo de imagen
  • Comparar licencias, opciones de prueba gratis, y más
    • [ ](/csharp-pdf.pdf)

    Visión general

    Acerca de IronPDF

    [IronPDF](/tutorials/html-to-pdf/) es una biblioteca HTML a PDF en C#. Permite a los ingenieros realizar tareas como crear archivos PDF desde fuentes como cadenas HTML, páginas web, URLs, y también establecer propiedades como marca de agua, marcador, encabezado y pie de página, entre otras. También podemos combinar múltiples archivos PDF en uno solo, o convertir páginas PDF en imágenes, o viceversa. Es gratis para el desarrollo y ofrece una prueba de implementación de 30 días para lanzar su proyecto. You can download a file project from this link.

    Acerca de Accusoft PrizmDoc Viewer

    [PrizmDoc Viewer](https://www.accusoft.com/products/prizmdoc-suite/prizmdoc-viewer-pdf/) 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 de archivo diferentes a PDF y de PDF a PNG, JPG, TIFF y SVG. También se puede utilizar para incluir diferentes tipos de opciones de firma electrónica en las aplicaciones.

    Tabla de comparación

    Trabajar con archivos PDF de manera programática. Trabajar con archivos PDF de manera programática. Soporta .NET Core con Windows, Mac o Linux. Soporta .NET Core usando Windows, Mac o Linux. Funciona localmente Envía documentos a un servidor remoto. Trabaja con o sin usar programación asíncrona. Debe usar programación asíncrona usando `System.Threading.Tasks`. Trabaja fácilmente sin conexión una vez que instalamos IronPDF en nuestro sistema. Debe conectarse a internet para enviar la solicitud al servidor de PrizmDoc Viewer (alojado en la nube o autoalojado). Proporciona muchas funciones predefinidas. Proporciona algunas funciones predefinidas. A menudo requiere mínimas líneas de código. A menudo requiere muchas líneas de código. Conversión ilimitada por proyecto en cada plan de licencia. Número limitado de transacciones en cada plan de licencia alojado en la nube. Gratis para el desarrollo sin límite de tiempo. Solo 300 transacciones con prueba. Instalemos los dos y comparemos el código.

    Paso 1: Instalación

    ## 1. Instalar la Biblioteca IronPDF Hay dos formas de instalar IronPDF en su proyecto, sin diferencia cuál adopte. ### 1.1. Descargar el DLL de IronPDF [Descargar IronPDF.dll](download-modal) y añadir su referencia a su proyecto. Después de esto, puede acceder fácilmente al espacio de nombres `IronPdf` de la siguiente manera: ```csharp using IronPdf; ``` Ahora, puede acceder fácilmente a las funciones y clases proporcionadas por IronPDF. ### 1.2 Instalar a través del Gestor de Paquetes NuGet * Consola del Gestor de Paquetes: Si está utilizando la Consola del Gestor de Paquetes, ejecute el siguiente comando: ```shell :ProductInstall ``` * Administrar Paquetes para la Solución: Si está utilizando la interfaz gráfica del [Gestor de Paquetes NuGet](https://www.nuget.org/packages/IronPdf), entonces 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. La otra es nuestro proyecto, con el que llegamos a esa API y obtenemos la respuesta.

    Acceder al PrizmDoc Server

    Como vemos por su nombre, es una aplicación del lado del servidor que obtiene la información básica del documento como solicitud (entrada) y convierte el documento a 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 procesamiento y conversión de documentos. Podemos usarlo de dos maneras diferentes, sin diferencia cuál adoptes porque ambos tienen la misma estructura y técnicas de programación: 1. **Autoalojado:** Para esta opción, necesita organizar su servidor, y puede [Descargar PrizmDoc Server](https://www.accusoft.com/products/prizmdoc-suite/prizmdoc-viewer-trial/) y luego instalarlo. [Leer más](https://help.accusoft.com/PrizmDoc/v13.14/HTML/install-on-windows.html) sobre cómo instalar PrizmDoc Server en Windows. **Nota:** Necesita un mínimo de 32 GB de RAM y 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 necesita organizar su servidor. Lo utilizaremos para nuestra comparación. Para hacer esto, [cree su cuenta](https://cloud.accusoft.com/signup) y luego se abrirá la página de inicio. Puede copiar `clave API` desde el menú de `Clave API`, veremos más adelante cómo usarla. Primero, veremos la estructura básica de cómo trabajar con PrizmDoc Viewer para convertir los documentos en un archivo PDF, y interactuaremos directamente con el `servidor de Accusoft` usando `WebClient()` en la aplicación de Consola de C#. **Nota:** El siguiente ejemplo es solo para comprensión conceptual de cómo PrizmDoc maneja los archivos PDF. Es un poco largo, así que no hay problema si omite este ejemplo y [pasa directamente a la comparación](#convert-html-to-a-pdf-file).

    Estructura de trabajo de Accusoft

    En este ejemplo, convertiremos el `myWebpage.html` al archivo `sample.pdf`. **Nota:** Tenemos que instalar la biblioteca `Newtonsoft.Json` y añadir su referencia en el proyecto. Primero, añada las siguientes bibliotecas a su proyecto: ```csharp using System; using System.IO; using System.Net; using System.Text; using System.Threading.Tasks; using Newtonsoft.Json.Linq; // Install Newtonsoft.Json via NuGet Package Manager ``` Luego, cree una variable pública `Clave API de Accusoft` y pegue su Clave API en ella de la siguiente manera: ```csharp static string ApiKey = "Your-API-KEY"; ``` Hay 3 pasos para tratar archivos PDF usando PrizmDoc Viewer: 1. Cargar un archivo al servidor de PrizmDoc. 2. Convertir el archivo cargado. 3. Descargar el archivo convertido del servidor PrizmDoc. Así que, haremos una función separada para cada paso. ```csharp 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)convertStatusResults.SelectToken("state"); //---Continuously checking whether conversion completed--- while (!(convertStatus.Equals("complete"))) { System.Threading.Thread.Sleep(30000); convertStatusResults = ConvertStatus(processId, affinityToken).Result; convertStatus = (string)convertStatusResults.SelectToken("state"); } //---Download the converted file from server--- string newFileID = (string)convertStatusResults.SelectToken("output.results[0].fileId"); DownloadFromServer(affinityToken, newFileID, "sample.pdf").Wait(); Console.WriteLine("PDF file created successfully...!"); Console.ReadKey(); } ``` **1. Cargar archivo al servidor:** ```csharp public static async Task UploadToServer(string fileToUpload) { FileInfo input = new FileInfo(fileToUpload); if (input == null) { throw new ArgumentException("Missing parameter input", nameof(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 = Encoding.ASCII.GetString(results); return JObject.Parse(getResult); } } } ``` **2. Convertir el archivo cargado a PDF:** ```csharp public static async Task 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); } } ``` El siguiente JSON es el valor resultante del objeto `myJson`: ```json { "input": { "sources": [ {"fileId": "Auto Generated FileId Value"} ], "dest": { "format": "pdf" } } } ``` **Verificar el estado de si la conversión está completa o no** ```csharp public static async Task 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); } } ``` **3. Descargar el archivo convertido del servidor** ```csharp 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); } } } ``` ¡El ejemplo anterior requiere mucho esfuerzo! Para minimizar la carga de trabajo, Accusoft presentó una biblioteca .NET llamada [Accusoft.PrizmDocServerSDK](https://www.nuget.org/packages/Accusoft.PrizmDocServerSDK/), que es un contenedor alrededor de la API REST del Servidor PrizmDoc. Veamos cómo instalar y usar esta biblioteca en nuestro proyecto .NET

    Instalar el Accusoft.PrizmDocServerSDK

    Hay dos maneras de instalar el contenedor. * Consola del Gestor de Paquetes: Si está utilizando la consola del gestor de paquetes, entonces ejecute el siguiente comando: ```shell Install-Package Accusoft.PrizmDocServerSDK ``` * Administrar Paquetes para la Solución: Si está utilizando la GUI del Gestor de Paquetes NuGet, entonces busque `Accusoft.PrizmDocServerSDK` en la barra de búsqueda e instálelo. Ahora, puede acceder fácilmente al espacio de nombres `Accusoft.PrizmDocServer` y usarlo accediendo: ```csharp using Accusoft.PrizmDocServer; ```

    Tutoriales sobre cómo hacer

    ## 2. IronPDF vs Código de Comparación de PrizmDoc Viewer Después de leer la introducción e instalación de ambos componentes, ahora es el momento de trabajar con ambos componentes. Para esto, tomaremos algunos casos de uso y los implementaremos usando ambos componentes. Esperamos que esto proporcione una forma de entender fácilmente ambas estructuras de programación y concluyamos cuál es la mejor para su proyecto.
    ## 3. Convertir HTML a Archivo 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 ```csharp 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"); } ``` 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:/sample.pdf");` [Leer más](/docs/#sample-html-file-to-pdf) sobre cómo trabajar con IronPDF para tratar con archivos PDF. Ahora, haremos la misma tarea usando el PrizmDoc Viewer, para que nuestra comparación sea fácil. ### 3.2. PrizmDoc Viewer HTML a PDF En la instalación de PrizmDoc Viewer, ya discutimos cómo obtener la `Clave API de Accusoft`, y ahora veremos cómo usarla. Primero, enviamos una solicitud al servidor de PrizmDoc y obtenemos una respuesta de él. Este proceso tomará un tiempo, por lo que necesitamos usar Programación Asíncrona. **Nota:** Asegúrese de que su sistema esté conectado a internet mientras crea archivos PDF usando servicios en la nube de PrizmDoc Viewer. ```csharp 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"); } ``` [Leer más](https://github.com/Accusoft/PrizmDocServerDotNetSDK/tree/master/Demos) sobre cómo trabajar con PrizmDoc Viewer. ### 3.3. Comparación de Código de HTML a PDF Vemos en estos ejemplos que IronPDF es un enfoque más simple 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 por la [Imagen](https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png), y existe en nuestra carpeta `debug` del proyecto. Empecemos con IronPDF. ### 4.1. IronPDF Imagen a PDF ```csharp using IronPdf; static void Main(string[] args) { // Specify the image to be converted using var converted = ImageToPdfConverter.ImageToPdf("google.png"); // Save PDF file to the target location converted.SaveAs("sample.pdf"); } ``` **Salida:** Esta captura de pantalla es de un archivo PDF recién creado `sample.pdf` usando el código anterior:
    Iron 2 related to Tutoriales sobre cómo hacer Podemos ver lo fácil que es crear un archivo PDF a partir de una imagen usando IronPDF. Ahora, haremos la misma tarea usando PrizmDoc Viewer y veremos su archivo PDF generado. ### 4.2. PrizmDoc Viewer Imagen a PDF ```csharp using Accusoft.PrizmDocServer; using Accusoft.PrizmDocServer.Conversion; 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 converted ConversionResult results = await prizmDocServer.ConvertToPdfAsync("google.png"); // Save PDF file to the target location await results.RemoteWorkFile.SaveAsync("sample.pdf"); } ``` **Salida:** This screenshot is of a newly created PDF file `sample.pdf` from the above code:
    Prizm 2 related to Tutoriales sobre cómo hacer ### 4.3. Comparación de Código de Imagen a PDF Podemos ver que solo necesitamos escribir 2 líneas de código simple usando IronPDF. Por otro lado, usando 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 de página completa utilizable.
    ## 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 hacer esta tarea usando ambos componentes. Primero, veremos cómo realizar esta tarea usando IronPDF. ### 5.1. IronPDF Fusionar Archivos PDF ```csharp 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(); 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(); } } ``` El código anterior creará un archivo `sample.pdf`, que es la combinación de `A.pdf`, `B.pdf`, y `C.pdf`. Ahora, haremos la misma tarea usando PrizmDoc Viewer. ### 5.2. PrizmDoc Viewer Fusionar Archivos PDF ```csharp 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"); } ``` 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 en PDF En esta comparación, supongamos que tenemos una página web simple llamada `myWebPage.html` que tiene el siguiente HTML y CSS: ```html

    Hello World..!

    Main Menu