Accusoft Prizmdoc PDF Viewer Anleitung und Vergleich

Accusoft PDF Viewer bietet HTML-zu-PDF-Funktionen und andere PDF-Bearbeitungs- und Manipulationsaufgaben für .NET. IronPDF erledigt dieselben Aufgaben auch programmatisch und spart Ihnen so Zeit und Mühe bei Ihren C#-Projekten.

Lassen Sie uns die beiden vergleichen und herausfinden, was für Ihr Projekt am besten geeignet ist.

IronPDF mit Accusoft PDF Viewer vergleichen

• HTML in PDF umwandeln
• Kopf- und Fußzeilen für PDFs festlegen
• PDF in Bilddatei konvertieren
• Lizenzierung, kostenlose Testoptionen und mehr vergleichen

Übersicht

Über IronPDF

IronPDF ist eine C# HTML-zu-PDF-Bibliothek. Es ermöglicht Ingenieuren, Aufgaben zu erledigen, einschließlich der Erstellung von PDF-Dateien aus Quellen wie HTML-String, WebPage, URL, sowie die Einstellung der Eigenschaften wie Wasserzeichen, Lesezeichen, Kopf-und Fußzeile usw. Wir können auch mehrere PDF-Dateien zu einer einzigen zusammenführen oder PDF-Seiten in Bilder umwandeln oder umgekehrt.

Es ist kostenlos für die Entwicklung und bietet eine 30-tägige Testversion, um mit Ihrem Projekt in Betrieb zu gehen.

Sie können ein Dateiprojekt von dieser Seite herunterladen link.

Über Accusoft PrizmDoc Viewer

PrizmDoc Betrachter ist eine REST-API, die für die Arbeit mit PDF-Dateien und deren Konvertierung in andere Formate per Fernzugriff verwendet wird. PrizmDoc kann über 100 verschiedene Dateiformate in PDF und PDF in PNG, JPG, TIFF und SVG konvertieren. Es kann auch verwendet werden, um verschiedene Arten von elektronischen Signaturen in die Anwendungen einzubinden.

Vergleichstabelle

Installieren wir die beiden und vergleichen wir den Code.

Schritt 1: Installation

1. Installieren Sie die IronPDF-Bibliothek

Es gibt zwei Möglichkeiten, IronPDF in Ihrem Projekt zu installieren, wobei es keinen Unterschied macht, welche Sie wählen.

1.1. Laden Sie die IronPDF DLL herunter

IronPDF.dll herunterladen und fügen Sie die Referenz zu Ihrem Projekt hinzu. Danach können Sie auf den Namespace "IronPDF" wie folgt zugreifen:

ironPDF verwenden"

Jetzt können Sie problemlos auf die bereitgestellten Funktionen und Klassen von IronPDF zugreifen.

1.2 Installation über NuGet Package Manager

• Paketmanager-Konsole:

   Wenn Sie die Paketmanager-Konsole verwenden, führen Sie den folgenden Befehl aus:

    :ProductInstall

• Verwalten Sie Pakete für die Lösung:

   Wenn Sie die grafische Benutzeroberfläche von [NuGet-Paketmanager](https://www.nuget.org/packages/IronPdf), dann suchen Sie `IronPDF` in der Suchleiste und installieren Sie es.

  ---

Installieren Sie den PrizmDoc Viewer von Accusoft

Es gibt zwei Teile von PrizmDoc Viewer, einer davon ist die Server-Seite namens "PrizmDoc Server", die sich wie eine Restful API verhält. Das andere ist unser Projekt, mit dem wir auf diese API zugreifen und die Antwort erhalten.

Zugriff auf den PrizmDoc Server

Wie aus dem Namen hervorgeht, handelt es sich um eine serverseitige Anwendung, die die grundlegenden Informationen über das Dokument als Anfrage erhält (eingabe) und konvertiert das Dokument in eine PDF-Datei und sendet die konvertierte PDF-Datei als Antwort an den Client (ausgabe). Es ist das technische Herzstück des Produkts, das eine Maschine zur Verarbeitung und Konvertierung von Dokumenten ist. Sie kann auf zwei verschiedene Arten verwendet werden, wobei es keinen Unterschied macht, welche Sie verwenden, da beide die gleiche Programmierstruktur und -technik haben:

1. Selbstgehostet:

   Für diese Option müssen Sie Ihren Server einrichten, und Sie können [PrizmDoc Server herunterladen](https://www.accusoft.com/products/prizmdoc-suite/prizmdoc-viewer-trial/)  dann installieren Sie es.[Mehr lesen](https://help.accusoft.com/PrizmDoc/v13.14/HTML/install-on-windows.html)  wie man PrizmDoc Server unter Windows installiert.
   
   **Hinweis:** Es benötigt mindestens 32 GB Ram und 4 Core CPU, andernfalls können Sie eine schlechte Erfahrung machen.

2. Cloud-gehostet:

   Es handelt sich um einen Cloud-basierten Service von PrizmDoc Viewer und Sie müssen keinen eigenen Server einrichten. Wir werden sie für unseren Vergleich verwenden. Um dies zu tun, [ihr Konto erstellen](https://cloud.accusoft.com/signup)  und dann wird die Homepage geöffnet. Sie können den "API-Schlüssel" aus dem Menü "API-Schlüssel" kopieren, wir werden später sehen, wie man ihn benutzt.

   Zuerst werden wir die grundlegende Struktur sehen, wie man mit PrizmDoc Viewer arbeitet, um die Dokumente in eine PDF-Datei zu konvertieren, und wir werden direkt mit dem "Accusoft Server" unter Verwendung des "WebClient" interagieren()` in C# Konsolenanwendung.

   Hinweis: Das folgende Beispiel dient nur dem konzeptionellen Verständnis, wie PrizmDoc mit PDF-Dateien umgeht. Es ist ein bisschen lang, also kein Problem, wenn Sie dieses Beispiel überspringen und direkt zum Vergleich übergehen.

   Accusoft Arbeitsstruktur

   In diesem Beispiel werden wir die Datei "myWebpage.html" in die Datei "sample.pdf" umwandeln.

Hinweis: Wir müssen die "Newtonsoft"-Bibliothek installieren und ihre Referenz in das Projekt aufnehmen.

Fügen Sie zunächst die folgenden Bibliotheken zu Ihrem Projekt hinzu:

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

Erstellen Sie dann eine öffentliche Variable Accusoft API Key und fügen Sie Ihren API-Schlüssel wie folgt ein:

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

Es gibt 3 Schritte, um eine PDF-Datei mit PrizmDoc Viewer zu bearbeiten:

1. Laden Sie eine Datei auf den PrizmDoc-Server hoch.

2. Konvertieren Sie die hochgeladene Datei.

3. Konvertierte Datei vom PrizmDoc-Server herunterladen.

   Wir werden also für jeden Schritt eine eigene Funktion erstellen.

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. Datei auf den Server hochladen:

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. Konvertieren Sie die hochgeladene Datei in 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

Das folgende JSON ist der resultierende Wert des Objekts "myJson":

{
  "input": {
    "sources": 
    [
      {"fileId": "Auto Generated FileId Value"}
    ],
    "dest": {
      "format": "pdf"
    }
  }
}

Prüfen Sie den Status, ob die Konvertierung abgeschlossen ist oder nicht

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. Laden Sie die konvertierte Datei vom Server herunter

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

Das obige Beispiel erfordert einen hohen Aufwand! Um die Arbeitsbelastung zu minimieren, hat Accusoft eine .NET-Bibliothek namens Accusoft.PrizmDocServerSDKes ist ein Wrapper um die PrizmDoc Server REST API. Schauen wir uns an, wie wir diese Bibliothek in unserem .NET-Projekt installieren und verwenden können

Installieren Sie das Accusoft.PrizmDocServerSDK

Es gibt zwei Möglichkeiten, den Wrapper zu installieren.

• Paketmanager-Konsole:

   Wenn Sie die Paketmanager-Konsole verwenden, führen Sie den folgenden Befehl aus:

    :InstallCmd install-package Accusoft.PrizmDocServerSDK

• Verwalten Sie Pakete für die Lösung:

   Wenn Sie die GUI von NuGet Package Manager verwenden, suchen Sie in der Suchleiste nach "Accusoft.PrizmDocServerSDK" und installieren Sie es.

  Jetzt können Sie einfach auf den Namespace "Accusoft.PrizmDocServer" zugreifen und ihn verwenden, indem Sie darauf zugreifen:

  Benutzung von Accusoft.PrizmDocServer;

  ---

Anleitungen Tutorials

2. IronPDF vs. PrizmDoc Viewer Code-Vergleich

Nachdem Sie die Einführung und die Installation der beiden Komponenten gelesen haben, ist es nun an der Zeit, mit beiden Komponenten zu arbeiten. Dazu werden wir einige Anwendungsfälle nehmen und sie mit beiden Komponenten umsetzen. Wir hoffen, dass dies eine Möglichkeit bietet, beide Programmierstrukturen zu verstehen und zu entscheiden, welche die beste für Ihr Projekt ist.

3. HTML in PDF-Datei konvertieren

In unserem ersten Vergleich nehmen wir den Anwendungsfall an, dass wir eine Webseite mit dem Namen "myWebPage.html" haben und daraus eine PDF-Datei erstellen und diese am Zielort speichern möchten.

3.1. IronPDF HTML zu 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

Der obige Code erstellt eine "sample.pdf"-Datei und speichert sie im bin>debug-Ordner des Projekts.

Sie können auch einen beliebigen Pfad wie diesen angeben: "PDF.SaveAs("E:/muster.pdf");`

Mehr lesen über die Arbeit mit IronPDF im Umgang mit PDF-Dateien.

Jetzt werden wir die gleiche Aufgabe mit dem PrizmDoc Viewer durchführen, um den Vergleich zu erleichtern.

3.2. PrizmDoc Viewer HTML zu PDF

In der PrizmDoc Viewer-Installation haben wir bereits besprochen, wie man den Accusoft API Key erhält, und jetzt werden wir sehen, wie man ihn benutzt.

Zunächst senden wir eine Anfrage an den PrizmDoc-Server und erhalten eine Antwort von ihm. Dieser Prozess wird einige Zeit in Anspruch nehmen, weshalb wir die asynchrone Programmierung verwenden müssen.

Hinweis: Stellen Sie sicher, dass Ihr System mit dem Internet verbunden ist, während Sie PDF-Dateien mit den Cloud-Diensten von PrizmDoc Viewer erstellen.

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

Mehr lesen wie man mit PrizmDoc Viewer arbeitet.

3.3. HTML zu PDF Code Vergleich

Anhand dieser Beispiele sehen wir, dass IronPDF eine einfachere Methode zur Erstellung von PDF-Dateien ist und nicht so viel Zeit in Anspruch nimmt.

4. Bild zu PDF

In diesem Vergleich gehen wir von einem Anwendungsfall aus, bei dem eine PDF-Datei mit dem Bildund es existiert in unserem debug-Ordner des Projekts. Beginnen wir mit IronPDF.

4.1. IronPDF Image to 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

Ausgang:

Dieser Screenshot zeigt eine mit dem obigen Code neu erstellte PDF-Datei "sample.pdf":

Wir können sehen, wie einfach es ist, mit IronPDF eine PDF-Datei aus einem Bild zu erstellen. Jetzt werden wir die gleiche Aufgabe mit dem PrizmDoc Viewer durchführen und die erzeugte PDF-Datei sehen.

4.2. PrizmDoc Viewer Bild zu 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

Ausgabe: Dieser Screenshot zeigt eine mit dem obigen Code neu erstellte PDF-Datei "sample.pdf":

4.3. Bild-zu-PDF-Code-Vergleich

Wir sehen, dass wir mit IronPDF nur 2 einfache Codezeilen schreiben müssen. Andererseits müssen wir bei der Verwendung des PrizmDoc-Servers viele Codezeilen mit asynchroner Programmierung schreiben. Die Ausgabe von IronPDF liefert auch automatisch ein brauchbares ganzseitiges Dokument.

5. PDF-Dateien zusammenführen

Bei diesem Vergleich nehmen wir an, dass wir drei PDF-Dateien mit den Namen A.pdf, B.pdf und C.pdf haben. Wir wollen sie in einer PDF-Datei zusammenführen, und wir können diese Aufgabe mit beiden Komponenten erledigen. Zunächst werden wir sehen, wie diese Aufgabe mit IronPDF durchgeführt werden kann.

5.1. IronPDF PDF-Dateien zusammenführen

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

Mit dem obigen Code wird eine Datei "sample.pdf" erstellt, die eine Kombination aus "A.pdf", "B.pdf" und "C.pdf" ist.

Jetzt werden wir die gleiche Aufgabe mit PrizmDoc Viewer durchführen.

5.2. PrizmDoc Viewer PDF-Dateien zusammenführen

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

Mit dem obigen Code wird auch eine "sample.pdf"-Datei erstellt, die eine Kombination aus den Dateien "A.pdf", "B.pdf" und "C.pdf" ist.

6. PDF-Kopfzeile und -Fußzeile

In diesem Vergleich nehmen wir an, dass wir eine einfache Webseite mit dem Namen "myWebPage.html" haben, die den folgenden HTML- und CSS-Code enthält:

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

Wir wollen diese Webseite in eine PDF-Datei umwandeln und die folgenden Kopf- und Fußzeileneigenschaften einstellen:

• "Seitentitel" auf der linken Seite der Kopfzeile,
• dateTime" auf der rechten Seite der Kopfzeile

• seitenzahl der Gesamtseiten" auf der rechten Seite der Fußzeile.

  Zuerst werden wir uns ansehen, wie man mit IronPDF arbeitet, um die Kopf- und Fußzeile einzustellen.

6.1. IronPDF PDF-Kopf- und Fußzeile

Für die Kopf- und Fußzeile einer PDF-Datei stellt IronPDF eine Eigenschaft der Klasse ChromePdfRenderer namens RenderingOptions zur Verfügung, die wie folgt verwendet werden kann:

• Für die Kopfzeile:

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

• Für die Fußzeile:

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

  Bei der Initialisierung von "TextHeaderFooter" können wir die folgenden Eigenschaften festlegen()`:

• CenterText, um den Text in der Mitte der Kopf- oder Fußzeile zu drucken.
• LeftText, um den Text auf der linken Seite der Kopf- oder Fußzeile zu drucken.
• RightText, um den Text auf der rechten Seite der Kopf- oder Fußzeile zu drucken.
• DrawDividerLine zeichnet eine Linie, die den Seiteninhalt von der Kopf- oder Fußzeile trennt.
• FontFamily zur Angabe der Schriftfamilie von Header oder Footer.
• FontSize zur Angabe der Schriftgröße der Kopf- oder Fußzeile.

• mit Abstand** wird der Abstand zwischen Seiteninhalt und Kopf- oder Fußzeile angepasst.

  Einige der folgenden vordefinierten Attribute sind sehr hilfreich, um den Inhalt von Kopf- und Fußzeilen festzulegen. Es kann in geschweiften Klammern geschrieben werden { } wie folgt:

• {seite} Es wird die aktuelle Seitenzahl in der Kopf- oder Fußzeile gedruckt.
• {gesamt-Seiten} Es wird die Gesamtzahl der Seiten in der Kopf- oder Fußzeile gedruckt.
• {url} wird verwendet, um die URL der gerenderten Seite zu drucken.
• {datum} Es wird das aktuelle Datum in der Kopf- oder Fußzeile gedruckt.
• {zeit} Es wird die aktuelle Uhrzeit in der Kopf- oder Fußzeile gedruckt.
• {html-title} Druckt den Titel der gerenderten Webseite in der Kopf- oder Fußzeile

• {pdf-Titel} Es druckt den Titel des Dokuments in der Kopf- oder Fußzeile.

  Mehr lesen wie Sie mit IronPDF mit Kopf- und Fußzeilen arbeiten können.

  Anhand des folgenden Beispiels soll gezeigt werden, wie die oben genannten Eigenschaften verwendet werden können, um die Kopf- und Fußzeile einer PDF-Datei festzulegen.

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

Ausgabe: Der Screenshot der mit dem obigen Code neu erstellten PDF-Datei "sample.pdf":

Wir können sehen, wie einfach es ist, mit Kopf- und Fußzeilen zu arbeiten, indem wir eine intuitive Sprache verwenden, während wir eine PDF-Datei mit IronPDF erstellen. Jetzt werden wir sehen, wie man mit PrizmDoc Viewer Kopf- und Fußzeilen einstellen kann.

6.2. PrizmDoc Viewer PDF-Kopf- und Fußzeile

PrizmDoc Viewer stellt die Klasse HeaderFooterOptions zur Verfügung, um mit Kopf- und Fußzeilen umzugehen, mit den folgenden Eigenschaften:

• Zeilen gibt die Zeile an(s) für Kopfzeile und Fußzeile(wird deutlicher, wenn Sie das folgende Beispiel verstehen)hat jede Zeile die folgenden Eigenschaften:

  • Links druckt den Text auf der linken Seite der Kopf- oder Fußzeile.

  • Mitte druckt den Text auf der linken Seite der Kopf- oder Fußzeile.
• Rechts druckt den Text auf der rechten Seite der Kopf- oder Fußzeile.
• FontFamily, um die Schriftfamilie des Kopf- oder Fußtextes anzugeben.
• FontSize, um die Schriftgröße des Kopf- oder Fußzeilentextes anzugeben.

• Farbe, um die Farbe des Kopf- oder Fußzeilentextes anzugeben.

  Mehr lesen wie man Kopf- und Fußzeilen einer PDF-Seite mit PrizmDoc Server einstellt.

  Sehen wir uns an, wie wir unseren Anwendungsfall unter Verwendung der oben genannten Eigenschaften umsetzen können.

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

Ausgang:

Der Screenshot der neu erstellten PDF-Datei mit obigem Code:

6.3. PDF-Kopf- und Fußzeilen-Codevergleich

Wir sehen, dass IronPDF im Vergleich zu PrizmDoc Viewer mehr Funktionen zum Einstellen von Kopf- und Fußzeileneigenschaften mit einer einfachen Programmierstruktur bietet. Es wird auch behauptet, dass die von IronPDF erzeugte PDF-Datei lesbarer und attraktiver ist als die von PrizmDoc Viewer erzeugte Datei.

7. PDF-Seiten in Bilder umwandeln

Nehmen wir einen weiteren Anwendungsfall: Wir haben eine einfache PDF-Datei mit dem Namen "Sample_PDF.pdf", die nur 2 Seiten hat.

Seite1	Seite2

Und wir müssen ein Bild von jeder Seite erstellen. Zunächst werden wir sehen, wie diese Aufgabe mit IronPDF durchgeführt werden kann.

7.1. IronPDF PDF in Bild konvertieren

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

Ausgang:

Mit dem obigen Code werden die folgenden zwei "png"-Bilder erstellt:

Seite1 Bild	Seite2 Bild

Wir können sehen, wie einfach es ist, mit IronPDF ein Bild von jeder PDF-Seite zu erstellen. Jetzt werden wir die gleiche Aufgabe mit PrizmDoc Viewer durchführen.

7.2. PrizmDoc Viewer PDF zu Bild

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

Ausgang:

Mit dem obigen Code werden auch die folgenden zwei "png"-Bilder erstellt:

Seite1	Seite2

7.3. PDF zu Image Code Vergleich

Im Vergleich zu PrizmDoc Viewer können wir mit IronPDF das Bild jeder Seite mit den wenigsten Codezeilen erzeugen, auch ohne die Seiten zu iterieren.

8. Preise für Lizenzen

In den obigen Vergleichen sehen wir die technische Arbeitsstruktur und die vorgesehenen Funktionen der beiden Komponenten. Nun werden wir uns die Lizenzpreise für beide Komponenten ansehen. Das ist sehr wichtig, weil wir immer versuchen, unsere Anforderungen mit einem minimalen Budget zu erfüllen.

8.1. IronPDF Lizenz-Optionen

Die IronPDF-Lizenz beginnt bei $749 für ein einzelnes Projekt mit einem Entwickler.

Wenn Sie Ingenieur in einem Unternehmen oder einer Agentur sind, das/die für mehrere Kunden arbeitet, beginnen die Lizenzen bei 699 US-Dollar und können je nach Teamgröße und Anzahl der Projekte angepasst werden.

Die folgende Lizenz erfordert nur eine einmalige Zahlung.

• Für Unternehmen mit mehreren Standorten beginnt die Lizenz bei $1199.
• Für SaaS-Dienste beginnen die Lizenzen bei $1099,

• Für den lizenzfreien OEM-Vertrieb beginnen die Lizenzen bei $1599,

  Hinweis: Alle oben genannten Lizenzpakete beinhalten 1 Jahr Support und Updates.

  Mehr lesen über alle angebotenen Lizenzpakete von IronPDF.

8.2. PrizmDoc Viewer Lizenz Optionen

Selbstgehostete Option

Wenn Sie Ihren eigenen Server verwalten, beträgt der Preis der Lizenz $7.900/Jahr mit Standard-Support.

Mehr lesen über alle bereitgestellten Paketinformationen von PrizmDoc Viewer.

Cloud-basierte Option

Diese Lizenz bezieht sich auf die Cloud-basierten Dienste von PrizmDoc Viewer, die auf Basis der Anzahl der Transaktionen skaliert werden.

Terminologien:

*transaktion" bedeutet, dass wir den PrizmDoc-Viewer-Server ansprechen und die Ausgabe erhalten (resultierendes Dokument).

*prepaid Buckets" bedeutet, dass Sie einmal zahlen und die Transaktionen erhalten, die nicht verfallen.

Tutorial Schnellzugriff

Holen Sie sich das C# IronPDF Quickstart-Handbuch

Wir haben ein kostenloses PDF-Ressourcenhandbuch erstellt, um die Entwicklung von PDFs für .NET zu vereinfachen. Darin werden gängige Funktionen und Beispiele für die Bearbeitung, Erstellung und Speicherung von PDFs in C# und VB.NET für Ihr Projekt erläutert.

Den Leitfaden herunterladen

Erkunden Sie die IronPDF API-Referenz

Entdecken Sie die API-Referenz für die IronPDF C# Library, einschließlich Details zu allen IronPDF-Funktionen, Klassen, Methodenfeldern, Namespaces und Enums.

Ansicht der API-Referenz