Ein Vergleich zwischen IronPDF und GrapeCity PDF Viewer

PDF steht für Portable Document Format. Es handelt sich um einen Dateityp, der die konventionelle Anzeige eines Dokuments auf vielen verschiedenen Geräten ermöglicht. PDFs werden häufig verwendet, um wichtige Dokumente wie Lebensläufe mit potenziellen Arbeitgebern oder Rechnungen mit Kunden auszutauschen.

Trotz ihrer Beliebtheit hat die Verwendung von PDF-Dateien für die Speicherung und den Austausch von Daten auch einige Nachteile. PDFs können zum Beispiel nicht per E-Mail weitergegeben werden, da sie zuerst in einem PDF-Reader geöffnet werden müssen. Selbst wenn dies möglich wäre, würden PDFs nicht so klar aussehen wie ein Word-Dokument, wenn sie auf einem Telefon geöffnet werden. Außerdem können PDF-Dateien nicht wie Word-Dokumente bearbeitet oder aktualisiert werden - es sei denn, Sie haben eine Bearbeitungssoftware auf Ihrem Computer installiert, die die Daten in der Datei erkennen und in eine bearbeitbare Form zurückverwandeln kann. Das bedeutet, dass PDF-Dateien beim Öffnen immer gleich aussehen, unabhängig davon, welches Gerät Sie verwenden - ob PC oder Mac. Dies macht PDF-Dateien auf allen Geräten zuverlässig, da sie einen vertrauten Standard implementieren, der in anderen Dokumentenformaten wie JPEG oder GIF nicht zu finden ist.

In diesem Artikel werden zwei .NET PDF-Bibliotheken vorgestellt:

• IronPDF
• TraubenStadt PDF

IronPDF

IronPDF ist eine .NET-Bibliothek, die mit nur wenigen Zeilen Code Funktionen zum Erstellen, Lesen und Bearbeiten von PDF-Dokumenten bereitstellt. Der folgende Artikel zeigt Ihnen, wie Sie mit IronPDF PDF-Dateien erstellen können. Der Inhalt setzt voraus, dass Sie die Grundlagen von Visual Studio oder C# verstehen und über HTML-Kenntnisse verfügen.

Wir benötigen Visual Studio zum Schreiben, Kompilieren und Ausführen unserer Anwendung, C# zum Schreiben von Logik und Code und HTML zum Formatieren von PDF-Dateien, einschließlich Hinzufügen von Titeln, Überschriften, Bildern, Absätzen usw. Die IronPDF-Bibliothek unterstützt vollständig .NET Core, .NET 5, Framework und Standard.

Wir können eine PDF-Datei in C# mit nur ein paar Zeilen Code erstellen. Mit Grundkenntnissen in C# und HTML ist dies eine einfache Aufgabe. Erfahren Sie mehr über IronPDF mit dieser link.

Installation von IronPDF

Die Entwicklung einer Lösung erfordert die Installation der NuGet Paket. Klicken Sie direkt in der Menüleiste auf "Projekt". Es erscheint eine Dropdown-Liste. Wählen Sie auf Verwalten NuGet-Pakete aus dem Dropdown-Menü und wählen Sie es aus. Es wird ein Fenster wie das folgende angezeigt:

Wählen Sie die Registerkarte "Durchsuchen", woraufhin ein Fenster wie das folgende erscheint:

Geben Sie "IronPDF" in das Suchfeld ein und drücken Sie "Enter". Das entsprechende Fenster sollte erscheinen:

Wählen Sie IronPDF:

Erstellen einer PDF-Datei in C# mit Ironpdfile

Wählen Sie die Schaltfläche "Installieren". Nach erfolgreicher Installation wird das entsprechende Fenster eingeblendet:

Sobald Sie die Schaltfläche "OK" drücken, können Sie loslegen.

Erstellen einer PDF-Datei

Hinzufügen des Namensraums IronPDF am Anfang der Datei.

using IronPdf;

using IronPdf;

Imports IronPdf

Ab diesem Punkt beginnt die eigentliche Arbeit. Wir benötigen einen Dateipfad, um das erstellte PDF-Dokument zu speichern. Dazu verwenden wir SaveFileDialog, das den Benutzer auffordert, einen Dateinamen und einen Dateipfad zu wählen.

private void Save_Click(object sender, EventArgs e)
{
    // Code to Select the folder and save the file.
    SaveFileDialog saveFileDialog1 = new SaveFileDialog();
    saveFileDialog1.InitialDirectory = @"D:\";
    saveFileDialog1.Title = "Save Pdf File";
    saveFileDialog1.DefaultExt = "pdf";
    saveFileDialog1.Filter = "Pdf files (*.pdf)
*.pdf
All files (*.*)
*.*";
    saveFileDialog1.FilterIndex = 2;
    saveFileDialog1.RestoreDirectory = true;
    if (saveFileDialog1.ShowDialog() == DialogResult.OK)
    {
        string filename = saveFileDialog1.FileName;
        // actual code that will create Pdf files
        var HtmlLine = new HtmlToPdf();
        HtmlLine.RenderHtmlAsPdf(PdfText.Text).SaveAs(filename);
        // MessageBox to display that file save
        MessageBox.Show("File Saved Successfully!");
    }
}

private void Save_Click(object sender, EventArgs e)
{
    // Code to Select the folder and save the file.
    SaveFileDialog saveFileDialog1 = new SaveFileDialog();
    saveFileDialog1.InitialDirectory = @"D:\";
    saveFileDialog1.Title = "Save Pdf File";
    saveFileDialog1.DefaultExt = "pdf";
    saveFileDialog1.Filter = "Pdf files (*.pdf)
*.pdf
All files (*.*)
*.*";
    saveFileDialog1.FilterIndex = 2;
    saveFileDialog1.RestoreDirectory = true;
    if (saveFileDialog1.ShowDialog() == DialogResult.OK)
    {
        string filename = saveFileDialog1.FileName;
        // actual code that will create Pdf files
        var HtmlLine = new HtmlToPdf();
        HtmlLine.RenderHtmlAsPdf(PdfText.Text).SaveAs(filename);
        // MessageBox to display that file save
        MessageBox.Show("File Saved Successfully!");
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

SaveFileDialog sollte einen Dateidialog öffnen, in dem Sie den Ordner und den Dateinamen an dem Ort auswählen können, an dem Sie ein PDF-Dokument erstellen möchten. Das ursprüngliche Verzeichnis ist auf Laufwerk D eingestellt, aber Sie können es auf ein beliebiges Verzeichnis einstellen. Da wir es nur mit PDF-Dateien zu tun haben, wurde die Standarderweiterung auf PDF-Dateien gesetzt.

In der "if"-Bedingung wird der eigentliche Code für die Erstellung der PDF-Datei eingefügt. Jetzt können wir sehen, dass es uns gelungen ist, mit nur zwei Codezeilen eine PDF-Datei zu erzeugen. PdfText ist der Name einer Rich-Text-Box, die den Text enthält, der in ein PDF-Dokument geschrieben wird. Der Dateiname ist der Dateipfad und -name, der über die Methode SaveFileDialog ausgewählt wurde.

PDFs lesen

Sie denken vielleicht, dass der Code für das Lesen von PDF-Dateien komplex und schwierig zu schreiben/zu verstehen ist - aber keine Sorge - IronPDF hat es leichter und einfacher gemacht. Für diesen Prozess sind lediglich zwei Zeilen Code erforderlich!

Fügen Sie den folgenden Code zum Importieren der IronPDF bibliothek am Anfang der Datei.

using IronPdf;
using System;
using System.Windows.Forms;

using IronPdf;
using System;
using System.Windows.Forms;

Imports IronPdf
Imports System
Imports System.Windows.Forms

Schreiben Sie den folgenden Code innerhalb der Funktion.

private void Read_Click(object sender, EventArgs e)
{
    PdfDocument PDF = PdfDocument.FromFile(FilePath.Text);
    FileContent.Text = PDF.ExtractAllText();
}

private void Read_Click(object sender, EventArgs e)
{
    PdfDocument PDF = PdfDocument.FromFile(FilePath.Text);
    FileContent.Text = PDF.ExtractAllText();
}

Private Sub Read_Click(ByVal sender As Object, ByVal e As EventArgs)
	Dim PDF As PdfDocument = PdfDocument.FromFile(FilePath.Text)
	FileContent.Text = PDF.ExtractAllText()
End Sub

Dadurch werden alle Informationen aus der Datenquelle in den Dokumentbetrachter extrahiert. Alle Berichtskomponenten werden diese Daten als Datenquelle verwenden.

GrapeCity PDF-Funktionen

GrapeCity Documents ist ein plattformübergreifendes Dokumentenmanagementsystem, das eine universelle Dokumenten-, Editor- und Reader-Lösung für alle gängigen Dokumentenformate bietet. Ohne ein zusätzliches Programm wie Adobe Acrobat zu benötigen, kann die umfangreiche Bibliothek des .NET-Standards 2.0 zum Lesen, Erzeugen, Ändern und Speichern von PDF-Dateien verwendet werden. Es verfügt über einen robusten Funktionsumfang, mit dem Entwickler PDF-Dateien erstellen können, die erweiterte Schriftarten, Fotos, Grafiken, Strichcodes, Kommentare, Umrisse, Stempel, Wasserzeichen und vieles mehr unterstützen.

Manipulation von PDFs

In .NET-Standard-Anwendungen können Sie GrapeCityPDF verwenden, um PDF-Dokumente mit einfachen oder komplizierten Geschäftsanforderungen zu erstellen. Außerdem können Sie PDF-Dateien aus beliebigen Quellen laden, ändern und speichern.

PDF als Bild speichern

Mit GrapeCityPDF können Sie ein PDF als Bild speichern, ohne die Bildqualität zu beeinträchtigen. Außerdem benötigen Sie nur wenige Zeilen Code, um diese Funktion zu implementieren.

PDF-Betrachter

GrapeCity Documents PDF Viewer ist ein leichtgewichtiger, programmierbarer Client-Viewer zur Anzeige von PDF-Dateien. Viele der üblichen PDF-Funktionen werden unterstützt.

Große Anzahl von Funktionen

Die GrapeCityPDF-Bibliothek verfügt über zahlreiche Funktionen, mit denen Sie komplizierte PDF-Dokumente erstellen können, die Informationen wie Text, Grafiken, Fotos, Anmerkungen, Gliederungen und mehr enthalten.

Installationen

Es gibt zwei Methoden, GrapeCity zu installieren.

1. Wählen Sie die Schaltfläche gepackte Quelldateien herunterladen, um die aktuellen Beispielquellen herunterzuladen.

2. Entpacken Sie die Dateien direkt aus der heruntergeladenen ZIP-Datei in ein Verzeichnis auf Ihrem Computer.

3. Navigieren Sie zu diesem Verzeichnis.

4. Führen Sie die Batch-Datei run.cmd aus. Dadurch werden die Beispielquellen erstellt. Starten Sie den SupportApi-Dienst und öffnen Sie die URL http://localhost:3003 in Ihrem Standardbrowser.

5. Weitere Informationen finden Sie in der Datei readme.MD, die in der heruntergeladenen ZIP-Datei enthalten ist.

Installation der WinForms-Ausgabe

Das folgende Thema beschreibt die Installation der WinForms Edition. Die folgenden Schritte enthalten Anweisungen zur Installation der WinForms Edition:

• Laden Sie das C1ControlPanel von https://www.grapecity.com/componentone um die neueste Ausgabe von WinForms zu installieren.
• Öffnen Sie das ControlPanel mit ComponentOneC1ControlPanel.exe. Alle laufenden Instanzen von Visual Studio müssen geschlossen werden.
• Ein bestehender Benutzer kann sich mit seiner registrierten E-Mail-Adresse und seinem Passwort anmelden.

• Wenn Sie ein neuer Benutzer sind:

  • Registrieren Sie sich bei Component One und erstellen Sie ein Konto, indem Sie die erforderlichen Felder ausfüllen.

  • Die Bestätigung wird an Ihre E-Mail-Adresse geschickt.

  • Aktivieren Sie Ihre E-Mail-Adresse, indem Sie den Verifizierungslink aufrufen.
• Wenn Sie sich nicht anmelden oder registrieren möchten, können Sie als anonymer Benutzer fortfahren.
• Wählen Sie in der Kachel WinForms Edition die Option Installieren. Sie können alle Editionen installieren, indem Sie das Kontrollkästchen Alle Editionen aktivieren. Klicken Sie auf die Schaltfläche Mehr anzeigen, um mehr über die Edition zu erfahren.
  

• Sobald Sie auf Installieren klicken, wird eine Seite mit der Lizenzvereinbarung angezeigt, auf der Sie aufgefordert werden, diese zu überprüfen, bevor Sie auf die Schaltfläche Lizenzvereinbarung akzeptieren klicken.
• Sobald Sie die Lizenzvereinbarung akzeptiert haben, erscheint eine Folgeseite mit den Schaltflächen Einstellungen und Verzeichnispfad ändern. Wählen Sie die Aufforderung Einstellungen akzeptieren, um den Verzeichnispfad zu überprüfen und den Installationsvorgang zu starten.
  

• Das Installationsprogramm installiert die Steuerelemente und zeigt dabei den Fortschritt an. Solange dieser Bildschirm angezeigt wird, können Sie den Installationsvorgang nicht abbrechen.
• Sobald die Steuerungen installiert sind, wird der Bildschirm "Installation erfolgreich" angezeigt. Die aktuell installierte Version wird in der jeweiligen Edition angezeigt.

• Das Installationsprogramm installiert die Steuerelemente und zeigt dabei den Fortschritt an. Solange dieser Bildschirm angezeigt wird, können Sie den Installationsvorgang nicht abbrechen.

  

• Sobald die Steuerungen installiert sind, wird der Bildschirm "Installation erfolgreich" angezeigt. Die aktuell installierte Version wird in der jeweiligen Edition angezeigt.
  

Erstellen einer PDF-Datei

using System;
using System.IO;
using System.Drawing;
using System.Text;
using GrapeCity.Documents.Text;
using GrapeCity.Documents.Common;
using GrapeCity.Documents.Drawing;
using GrapeCity.Documents.Pdf;
using GrapeCity.Documents.Pdf.Structure;
using GrapeCity.Documents.Pdf.MarkedContent;
using GrapeCity.Documents.Pdf.Graphics;
using GrapeCity.Documents.Pdf.Annotations;
using GCTEXT = GrapeCity.Documents.Text;
using GCDRAW = GrapeCity.Documents.Drawing;
namespace GcPdfWeb.Samples.Basics
{
    // This sample shows how to create a PDF/A-3u compliant document.
    public class PdfA
    {
        public void CreatePDF(Stream stream)
        {
            var doc = new GcPdfDocument();
            var date = new DateTime(1961, 4, 12, 6, 7, 0, DateTimeKind.Utc);

            // Mark the document as PDF/A-3u conformant:
            doc.ConformanceLevel = PdfAConformanceLevel.PdfA3u;

            var fnt = GCTEXT.Font.FromFile(Path.Combine("Resources", "Fonts", "arial.ttf"));
            var gap = 36;

            // PDF/A-3a requires all content to be tagged so create and populate StructElement when rendering:
            StructElement sePart = new StructElement("Part");
            doc.StructTreeRoot.Children.Add(sePart);

            TextLayout tl = null;
            // Add 3 pages with sample content tagged according to PDF/A rules:
            for (int pageNo = 1; pageNo <= 3; ++pageNo)
            {
                // add page
                var page = doc.Pages.Add();
                var g = page.Graphics;
                float y = 72;
                if (doc.Pages.Count == 1)
                {
                    // Create paragraph element:
                    var seParagraph = new StructElement("P") { DefaultPage = page };
                    // Add it to Part element:
                    sePart.Children.Add(seParagraph);

                    tl = g.CreateTextLayout();
                    tl.MarginAll = 72;
                    tl.MaxWidth = page.Size.Width;

                    tl.DefaultFormat.Font = fnt;
                    tl.DefaultFormat.FontBold = true;
                    tl.DefaultFormat.FontSize = 20;
                    tl.Append("PDF/A-3A Document");

                    // PerformLayout is done automatically in a new TextLayout or after a Clear():
                    //tl.PerformLayout(true);

                    // Draw TextLayout within tagged content:
                    g.BeginMarkedContent(new TagMcid("P", 0));
                    g.DrawTextLayout(tl, PointF.Empty);
                    g.EndMarkedContent();

                    y = tl.ContentRectangle.Bottom + gap;

                    seParagraph.ContentItems.Add(new McidContentItemLink(0));
                }

                // Add some sample paragraphs tagged according to PDF/A rules:
                for (int i = 1; i <= 3; ++i)
                {
                    // Create paragraph element:
                    var seParagraph = new StructElement("P") { DefaultPage = page };
                    // Add it to Part element:
                    sePart.Children.Add(seParagraph);

                    var sb = new StringBuilder();
                    sb.Append(string.Format("Paragraph {0} on page {1}: ", i, pageNo));
                    sb.Append(Common.Util.LoremIpsum(1, 2, 4, 5, 10));
                    var para = sb.ToString();

                    tl.Clear();
                    tl.DefaultFormat.FontSize = 14;
                    tl.DefaultFormat.FontBold = false;
                    tl.MarginTop = y;
                    tl.Append(para);

                    // Draw TextLayout within tagged content:
                    g.BeginMarkedContent(new TagMcid("P", i));
                    g.DrawTextLayout(tl, PointF.Empty);
                    g.EndMarkedContent();

                    y += tl.ContentHeight + gap;

                    // Add content item to paragraph StructElement:
                    seParagraph.ContentItems.Add(new McidContentItemLink(i));

                    // PDF/A-3 allows embedding files into document, but they should be associated with some document element
                    // add embedded file associated with seParagraph:
                    var ef1 = EmbeddedFileStream.FromBytes(doc, Encoding.UTF8.GetBytes(para));
                    // ModificationDate and MimeType should be specified in case of PDF/A:
                    ef1.ModificationDate = date;
                    ef1.MimeType = "text/plain";
                    var fn = string.Format("Page{0}_Paragraph{1}.txt", pageNo, i);
                    var fs1 = FileSpecification.FromEmbeddedStream(fn, ef1);
                    // UnicodeFile.FileName should be specified for PDF/A compliance:
                    fs1.UnicodeFile.FileName = fs1.File.FileName;
                    // Relationship should be specified in case of PDF/A:
                    fs1.Relationship = AFRelationship.Unspecified;
                    doc.EmbeddedFiles.Add(fn, fs1);
                    seParagraph.AssociatedFiles.Add(fs1);
                }
            }

            // PDF/A-3 allows transparency drawing in PDF file, add some:
            var gpage = doc.Pages [0].Graphics;
            gpage.FillRectangle(new RectangleF(20, 20, 200, 200), Color.FromArgb(40, Color.Red));

            // PDF/A-3 allows using FormXObjects, add one with transparency:
            var r = new RectangleF(0, 0, 144, 72);
            var fxo = new FormXObject(doc, r);
            var gfxo = fxo.Graphics;
            gfxo.FillRectangle(r, Color.FromArgb(40, Color.Violet));
            TextFormat tf = new TextFormat()
            {
                Font = fnt,
                FontSize = 16,
                ForeColor = Color.FromArgb(100, Color.Black),
            };
            gfxo.DrawString("FormXObject", tf, r, TextAlignment.Center, ParagraphAlignment.Center);
            gfxo.DrawRectangle(r, Color.Blue, 3);
            gpage.DrawForm(fxo, new RectangleF(300, 250, r.Width, r.Height), null, ImageAlign.ScaleImage);

            // PDF/A-3 allows using embedded files, but each embedded file must be associated with a document's element:
            EmbeddedFileStream ef = EmbeddedFileStream.FromFile(doc, Path.Combine("Resources", "WordDocs", "ProcurementLetter.docx"));
            // ModificationDate and MimeType should be specified for EmbeddedFile in PDF/A:
            ef.ModificationDate = date;
            ef.MimeType = "application/msword";
            var fs = FileSpecification.FromEmbeddedFile(ef);
            fs.UnicodeFile.FileName = fs.File.FileName;
            fs.Relationship = AFRelationship.Unspecified;
            doc.EmbeddedFiles.Add("ProcurementLetter.docx", fs);
            // Associate embedded file with the document:
            doc.AssociatedFiles.Add(fs);

            // Add an attachment associated with an annotation:
            var sa = new StampAnnotation()
            {
                UserName = "Minerva",
                Font = fnt,
                Rect = new RectangleF(300, 36, 220, 72),
            };
            sa.Flags 
= AnnotationFlags.Print;
            // Use a FormXObject to represent the stamp annotation:
            var stampFxo = new FormXObject(doc, new RectangleF(PointF.Empty, sa.Rect.Size));
            var gstampFxo = stampFxo.Graphics;
            gstampFxo.FillRectangle(stampFxo.Bounds, Color.FromArgb(40, Color.Green));
            gstampFxo.DrawString("Stamp Annotation\nassociated with minerva.jpg", tf, stampFxo.Bounds, TextAlignment.Center, ParagraphAlignment.Center);
            gstampFxo.DrawRectangle(stampFxo.Bounds, Color.Green, 3);
            //
            sa.AppearanceStreams.Normal.Default = stampFxo;
            doc.Pages [0].Annotations.Add(sa);
            ef = EmbeddedFileStream.FromFile(doc, Path.Combine("Resources", "Images", "minerva.jpg"));
            ef.ModificationDate = date;
            ef.MimeType = "image/jpeg";
            fs = FileSpecification.FromEmbeddedFile(ef);
            fs.UnicodeFile.FileName = fs.File.FileName;
            fs.Relationship = AFRelationship.Unspecified;
            doc.EmbeddedFiles.Add("minerva.jpg", fs);
            sa.AssociatedFiles.Add(fs);

            // Mark the document as conforming to Tagged PDF conventions (required for PDF/A):
            doc.MarkInfo.Marked = true;

            // Metadata.CreatorTool and DocumentInfo.Creator should be the same for a PDF/A document:
            doc.Metadata.CreatorTool = doc.DocumentInfo.Creator;
            // A title should be specified for PDF/A document:
            doc.Metadata.Title = "GcPdf Document";
            doc.ViewerPreferences.DisplayDocTitle = true;

            // Done:
            doc.Save(stream);
        }
    }
}

using System;
using System.IO;
using System.Drawing;
using System.Text;
using GrapeCity.Documents.Text;
using GrapeCity.Documents.Common;
using GrapeCity.Documents.Drawing;
using GrapeCity.Documents.Pdf;
using GrapeCity.Documents.Pdf.Structure;
using GrapeCity.Documents.Pdf.MarkedContent;
using GrapeCity.Documents.Pdf.Graphics;
using GrapeCity.Documents.Pdf.Annotations;
using GCTEXT = GrapeCity.Documents.Text;
using GCDRAW = GrapeCity.Documents.Drawing;
namespace GcPdfWeb.Samples.Basics
{
    // This sample shows how to create a PDF/A-3u compliant document.
    public class PdfA
    {
        public void CreatePDF(Stream stream)
        {
            var doc = new GcPdfDocument();
            var date = new DateTime(1961, 4, 12, 6, 7, 0, DateTimeKind.Utc);

            // Mark the document as PDF/A-3u conformant:
            doc.ConformanceLevel = PdfAConformanceLevel.PdfA3u;

            var fnt = GCTEXT.Font.FromFile(Path.Combine("Resources", "Fonts", "arial.ttf"));
            var gap = 36;

            // PDF/A-3a requires all content to be tagged so create and populate StructElement when rendering:
            StructElement sePart = new StructElement("Part");
            doc.StructTreeRoot.Children.Add(sePart);

            TextLayout tl = null;
            // Add 3 pages with sample content tagged according to PDF/A rules:
            for (int pageNo = 1; pageNo <= 3; ++pageNo)
            {
                // add page
                var page = doc.Pages.Add();
                var g = page.Graphics;
                float y = 72;
                if (doc.Pages.Count == 1)
                {
                    // Create paragraph element:
                    var seParagraph = new StructElement("P") { DefaultPage = page };
                    // Add it to Part element:
                    sePart.Children.Add(seParagraph);

                    tl = g.CreateTextLayout();
                    tl.MarginAll = 72;
                    tl.MaxWidth = page.Size.Width;

                    tl.DefaultFormat.Font = fnt;
                    tl.DefaultFormat.FontBold = true;
                    tl.DefaultFormat.FontSize = 20;
                    tl.Append("PDF/A-3A Document");

                    // PerformLayout is done automatically in a new TextLayout or after a Clear():
                    //tl.PerformLayout(true);

                    // Draw TextLayout within tagged content:
                    g.BeginMarkedContent(new TagMcid("P", 0));
                    g.DrawTextLayout(tl, PointF.Empty);
                    g.EndMarkedContent();

                    y = tl.ContentRectangle.Bottom + gap;

                    seParagraph.ContentItems.Add(new McidContentItemLink(0));
                }

                // Add some sample paragraphs tagged according to PDF/A rules:
                for (int i = 1; i <= 3; ++i)
                {
                    // Create paragraph element:
                    var seParagraph = new StructElement("P") { DefaultPage = page };
                    // Add it to Part element:
                    sePart.Children.Add(seParagraph);

                    var sb = new StringBuilder();
                    sb.Append(string.Format("Paragraph {0} on page {1}: ", i, pageNo));
                    sb.Append(Common.Util.LoremIpsum(1, 2, 4, 5, 10));
                    var para = sb.ToString();

                    tl.Clear();
                    tl.DefaultFormat.FontSize = 14;
                    tl.DefaultFormat.FontBold = false;
                    tl.MarginTop = y;
                    tl.Append(para);

                    // Draw TextLayout within tagged content:
                    g.BeginMarkedContent(new TagMcid("P", i));
                    g.DrawTextLayout(tl, PointF.Empty);
                    g.EndMarkedContent();

                    y += tl.ContentHeight + gap;

                    // Add content item to paragraph StructElement:
                    seParagraph.ContentItems.Add(new McidContentItemLink(i));

                    // PDF/A-3 allows embedding files into document, but they should be associated with some document element
                    // add embedded file associated with seParagraph:
                    var ef1 = EmbeddedFileStream.FromBytes(doc, Encoding.UTF8.GetBytes(para));
                    // ModificationDate and MimeType should be specified in case of PDF/A:
                    ef1.ModificationDate = date;
                    ef1.MimeType = "text/plain";
                    var fn = string.Format("Page{0}_Paragraph{1}.txt", pageNo, i);
                    var fs1 = FileSpecification.FromEmbeddedStream(fn, ef1);
                    // UnicodeFile.FileName should be specified for PDF/A compliance:
                    fs1.UnicodeFile.FileName = fs1.File.FileName;
                    // Relationship should be specified in case of PDF/A:
                    fs1.Relationship = AFRelationship.Unspecified;
                    doc.EmbeddedFiles.Add(fn, fs1);
                    seParagraph.AssociatedFiles.Add(fs1);
                }
            }

            // PDF/A-3 allows transparency drawing in PDF file, add some:
            var gpage = doc.Pages [0].Graphics;
            gpage.FillRectangle(new RectangleF(20, 20, 200, 200), Color.FromArgb(40, Color.Red));

            // PDF/A-3 allows using FormXObjects, add one with transparency:
            var r = new RectangleF(0, 0, 144, 72);
            var fxo = new FormXObject(doc, r);
            var gfxo = fxo.Graphics;
            gfxo.FillRectangle(r, Color.FromArgb(40, Color.Violet));
            TextFormat tf = new TextFormat()
            {
                Font = fnt,
                FontSize = 16,
                ForeColor = Color.FromArgb(100, Color.Black),
            };
            gfxo.DrawString("FormXObject", tf, r, TextAlignment.Center, ParagraphAlignment.Center);
            gfxo.DrawRectangle(r, Color.Blue, 3);
            gpage.DrawForm(fxo, new RectangleF(300, 250, r.Width, r.Height), null, ImageAlign.ScaleImage);

            // PDF/A-3 allows using embedded files, but each embedded file must be associated with a document's element:
            EmbeddedFileStream ef = EmbeddedFileStream.FromFile(doc, Path.Combine("Resources", "WordDocs", "ProcurementLetter.docx"));
            // ModificationDate and MimeType should be specified for EmbeddedFile in PDF/A:
            ef.ModificationDate = date;
            ef.MimeType = "application/msword";
            var fs = FileSpecification.FromEmbeddedFile(ef);
            fs.UnicodeFile.FileName = fs.File.FileName;
            fs.Relationship = AFRelationship.Unspecified;
            doc.EmbeddedFiles.Add("ProcurementLetter.docx", fs);
            // Associate embedded file with the document:
            doc.AssociatedFiles.Add(fs);

            // Add an attachment associated with an annotation:
            var sa = new StampAnnotation()
            {
                UserName = "Minerva",
                Font = fnt,
                Rect = new RectangleF(300, 36, 220, 72),
            };
            sa.Flags 
= AnnotationFlags.Print;
            // Use a FormXObject to represent the stamp annotation:
            var stampFxo = new FormXObject(doc, new RectangleF(PointF.Empty, sa.Rect.Size));
            var gstampFxo = stampFxo.Graphics;
            gstampFxo.FillRectangle(stampFxo.Bounds, Color.FromArgb(40, Color.Green));
            gstampFxo.DrawString("Stamp Annotation\nassociated with minerva.jpg", tf, stampFxo.Bounds, TextAlignment.Center, ParagraphAlignment.Center);
            gstampFxo.DrawRectangle(stampFxo.Bounds, Color.Green, 3);
            //
            sa.AppearanceStreams.Normal.Default = stampFxo;
            doc.Pages [0].Annotations.Add(sa);
            ef = EmbeddedFileStream.FromFile(doc, Path.Combine("Resources", "Images", "minerva.jpg"));
            ef.ModificationDate = date;
            ef.MimeType = "image/jpeg";
            fs = FileSpecification.FromEmbeddedFile(ef);
            fs.UnicodeFile.FileName = fs.File.FileName;
            fs.Relationship = AFRelationship.Unspecified;
            doc.EmbeddedFiles.Add("minerva.jpg", fs);
            sa.AssociatedFiles.Add(fs);

            // Mark the document as conforming to Tagged PDF conventions (required for PDF/A):
            doc.MarkInfo.Marked = true;

            // Metadata.CreatorTool and DocumentInfo.Creator should be the same for a PDF/A document:
            doc.Metadata.CreatorTool = doc.DocumentInfo.Creator;
            // A title should be specified for PDF/A document:
            doc.Metadata.Title = "GcPdf Document";
            doc.ViewerPreferences.DisplayDocTitle = true;

            // Done:
            doc.Save(stream);
        }
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

GrapeCityPDF ist keine fortgeschrittene Bibliothek für PDFs - sie hat im Vergleich zu IronPDF eine begrenzte Anzahl von Funktionen.

IronPDF Lizenzmodelle und Preisgestaltung

Die 30-Tage-Geld-zurück-Garantie: Sobald Sie die Lizenz erworben haben, erhalten Sie eine 30-tägige Geld-zurück-Garantie. Sollte die Lizenz nicht Ihren Anforderungen entsprechen, garantiert Ihnen IronPDF die Rückerstattung Ihres Geldes innerhalb von 30 Tagen.

Einfache Integration: Die Integration von IronPDF in ein laufendes Projekt und Ihre Umgebung ist ein nahtloser Prozess, der mit einer einzigen Codezeile abgeschlossen wird. Dies kann bei der Integration mit der NuGet-Paket-Methode erreicht werden oder direkt online heruntergeladen und in Ihre Umgebung integriert werden.

Dauerlizenzierung: Jede Lizenz wird nur einmal erworben und muss nicht erneuert werden.

Kostenloser Support und Produkt-Updates: Jede Lizenz beinhaltet einen Rund-um-die-Uhr-Support direkt durch das Team, das hinter dem Produkt steht, sowie ein Jahr lang kostenlose Produkt-Updates. Es ist jederzeit möglich, Erweiterungen zu kaufen. Die Erweiterungen können vor dem Kauf besichtigt werden.

Sofortige Lizenzen: Sobald die Zahlung eingegangen ist, werden registrierte Lizenzschlüssel verschickt.

Alle Lizenzen sind unbefristet und gelten für Staging, Entwicklung und Produktion.

Das Lite-Paket

• 1 Entwickler
• 1 Standort
• 1 Projekt

• Unbefristete Lizenz

  Dieses Paket ermöglicht es einem einzelnen Softwareentwickler in einem Unternehmen, Iron Software an einem Ort zu nutzen. Iron Software kann in einer einzelnen Intranetanwendung, einer Webanwendung oder einem Desktop-Softwareprogramm eingesetzt werden. Es ist verboten, Lizenzen außerhalb einer Organisation oder einer Agentur/Kundenbeziehung weiterzugeben, da sie nicht übertragbar sind. Dieser Lizenztyp, wie auch alle anderen Lizenztypen, schließt ausdrücklich alle Rechte aus, die nicht ausdrücklich im Rahmen der Vereinbarung gewährt werden, ohne OEM-Weitergabe und Nutzung der Iron Software als SaaS ohne den Erwerb einer zusätzlichen Abdeckung.

  Preisgestaltung: ab $749 pro Jahr.

Berufliche Lizenz

• 10 Entwickler
• 10 Standorte
• 10 Projekte

• Unbefristete Lizenz

  Diese Lizenz erlaubt es einer bestimmten Anzahl von Softwareentwicklern in einem Unternehmen, Iron Software an zahlreichen Standorten zu nutzen, maximal jedoch zehn. Iron Software kann in beliebig vielen Websites, Intranetanwendungen oder Desktop-Softwareanwendungen verwendet werden. Die Lizenzen sind nicht übertragbar und dürfen daher nicht außerhalb einer Organisation oder einer Agentur/Kundenbeziehung weitergegeben werden. Dieser Lizenztyp, wie auch alle anderen Lizenztypen, schließt ausdrücklich alle Rechte aus, die nicht ausdrücklich im Rahmen der Vereinbarung gewährt werden, einschließlich der OEM-Weitergabe und der Nutzung der Iron Software als SaaS ohne Erwerb einer zusätzlichen Abdeckung. Diese Lizenz kann in ein einzelnes Projekt integriert werden, bis zu einer Höchstzahl von 10.

  Preisgestaltung: Ab $999 pro Jahr.

Unbegrenzte Lizenz

• Unbegrenzte Anzahl von Entwicklern
• Unbegrenzte Standorte
• Unbegrenzte Projekte

• Unbefristete Lizenz

  Dies ermöglicht es Ihnen, eine unbegrenzte Anzahl von Softwareentwicklern in einer einzigen Organisation zu haben, die Iron Software an einer unbegrenzten Anzahl von Standorten einsetzen können. Iron Software kann in beliebig vielen Intranetanwendungen, Desktop-Softwareanwendungen oder Websites verwendet werden. Die Lizenzen sind nicht übertragbar und können nicht außerhalb einer Organisation oder einer Agentur-/Kundenbeziehung weitergegeben werden. Dieser Lizenztyp, wie auch alle anderen Lizenztypen, schließt ausdrücklich alle Rechte aus, die nicht im Rahmen der Vereinbarung gewährt werden, einschließlich der OEM-Weitergabe und der Nutzung der Iron Software als SaaS ohne Erwerb einer zusätzlichen Abdeckung.

  Preise: Ab $ 2999 pro Jahr.

  Royalty-Free Redistribution: Dies erlaubt Ihnen, die Iron Software als Teil verschiedener kommerzieller Produkte zu vertreiben, die unterschiedlich verpackt sind (ohne Lizenzgebühren zahlen zu müssen) basierend auf der Anzahl der Projekte, die von der Basislizenz abgedeckt werden. Dies ermöglicht die Bereitstellung von Iron Software im Rahmen von SaaS-Softwarediensten, die auf der Anzahl der von der Basislizenz abgedeckten Projekte basiert.

  Preise: Ab $ 1599 pro Jahr.

  

GrapeCity PDF-Lizenzmodelle und Preisgestaltung

Dokumente für PDF

• Enthält 1 Entwicklerlizenz

• 1 Vertriebsstandort

  Dieses Paket enthält eine Entwicklerlizenz und nur einen Vertriebsstandort ohne Support und Wartung.

  Preisgestaltung: Ab $999 pro Jahr.

Dokumente für PDF Unlimited

• Enthält 1 Entwicklerlizenz

• Unbegrenzte Vertriebsstandorte

  Dieses Paket enthält eine Entwicklerlizenz mit einer unbegrenzten Anzahl von Vertriebsstandorten. Support und Wartung sind nicht inbegriffen. GrapeCity unterstützt nicht die SaaS und OEM.

  Preisgestaltung: ab $2799 pro Jahr.

Dokumente für PDF Team Unlimited

• Beinhaltet 5 Entwicklerlizenzen

• Unbegrenzte Vertriebsstandorte

  Dieses Paket enthält fünf Entwicklerlizenzen mit unbegrenzten Vertriebsstandorten ohne Support und Wartung. GrapeCity unterstützt kein SaaS und OEM.

  Preise: beginnen bei $5799 pro Jahr.

  

  Das IronPDF Lite One-Developer-Paket wird mit 1 Jahr Support geliefert und kostet etwa $749. Während GrapeCity Documents for PDF, ein One-Developer-Paket enthält und $999 ohne Support kostet. Das IronPDF Professional Package, das das 10-Entwickler-Paket und ein Jahr Support beinhaltet, kostet $999. Auf der anderen Seite hat GrapeCity kein 10-Entwickler-Paket - mit nur einem 5-Entwickler-Paket, das $5799 kostet.

Die IronPDF Lite- und Professional-Pakete bieten SaaS-Service oder OEM sowie eine 5-Jahres-Supportoption. Das Lite-Paket für einen Entwickler bietet fünf Jahre Support, SaaS und OEM-Services und kostet 2897 US-Dollar. GrapeCity bietet zwar kein SaaS, keinen OEM-Service und keine 5-Jahres-Supportoption an. Das Iron Professional 10-Entwicklerpaket umfasst 5 Jahre Support, Saas- und OEM-Services und kostet 3397 US-Dollar. GrapeCity hat zwar kein 10-Entwickler-Paket.

Schlussfolgerung

GrapeCity Documents for PDF ermöglicht Entwicklern den Export/Import, die Erstellung von AcroForms (PDF-Formulare)und PDFs in zahlreichen Desktop-Anwendungen ausführen. Mit GrapeCity Dokumente für PDF(GcPdf)sind Sie auf dem besten Weg, Ihren Kunden komplette PDF-Lösungen anzubieten.

Wir empfehlen IronPDF, da das Produkt eine höhere Genauigkeit bietet. Bei Mitbewerbern, die ähnliche Funktionen ausführen, kann es zu Ungenauigkeiten kommen, wie z. B. dass einige Bilder nicht konvertiert werden können, was zu unbekannten Zeichen führt. IronPDF hingegen liefert genaue Ergebnisse.

IronPDF-Pakete bieten eine wettbewerbsfähige Lizenzierung und Unterstützung ohne laufende Kosten. IronPDF beginnt bei $749 mit Paketen, die eine größere Bandbreite an Funktionen beinhalten. GrapeCity PDF kostet ab $1649 pro Jahr. IronPDF unterstützt auch mehrere Plattformen zu einem einzigen Preis!

Wenn Sie noch kein IronPDF-Kunde sind, können Sie die kostenlose Testversion nutzen, um alle verfügbaren Funktionen zu testen. Wenn Sie die komplette Iron Suite kaufen, erhalten Sie alle fünf Produkte zum Preis von zwei. Für weitere Einzelheiten zu lizenzierungfolgen Sie bitte dieser Anleitung link um die vollständigen Informationen zum Paket einzusehen.