Zum Fußzeileninhalt springen
PDF-WERKZEUGE

IronPDF vs GrapeCity PDF: Ein .NET PDF-Bibliotheksvergleich

IronPDF ist spezialisiert auf die HTML-zu-PDF-Erstellung mit der Chrome V8-Rendering-Engine for .NET-Anwendungen, während sich GrapeCity PDF auf PDF-Anzeige- und Anmerkungsfunktionen konzentriert, was IronPDF zur überlegenen Wahl für Entwickler macht, die vollständige PDF-Erstellungsmöglichkeiten mit Unterstützung für moderne Webinhalte benötigen.

PDF steht für Portable Document Format. Es handelt sich um einen Dateityp, der die herkömmliche Anzeige von Dokumenten auf vielen verschiedenen Geräten ermöglicht. PDFs werden häufig verwendet, um wichtige Dokumente wie Lebensläufe an potenzielle Arbeitgeber oder Rechnungen an Kunden zu übermitteln.

Trotz ihrer Beliebtheit weisen PDFs einige Einschränkungen auf. Beispielsweise können Sie PDFs nicht per E-Mail versenden, ohne dass die Empfänger einen PDF-Reader benötigen. PDFs werden auf Mobilgeräten möglicherweise nicht so klar angezeigt wie Word-Dokumente. Darüber hinaus benötigen PDFs im Gegensatz zu Word-Dokumenten eine Bearbeitungssoftware , um Inhalte zu ändern oder zu aktualisieren. PDF-Dateien behalten jedoch auf allen Geräten – egal ob PC oder Mac – ein einheitliches Erscheinungsbild. Diese Zuverlässigkeit macht PDFs zu einem Standardformat, das bei anderen Dokumenttypen wie JPEG oder GIF nicht zu finden ist.

In diesem Artikel werden wir zwei .NET PDF-Bibliotheken überprüfen:

  • IronPDF
  • GrapeCity PDF

Was ist IronPDF und wie vergleicht es sich mit GrapeCity?

IronPDF ist eine .NET Bibliothek, die Funktionen zum Erstellen, Lesen und Bearbeiten von PDF-Dokumenten mit minimalem Codeaufwand bereitstellt. Dieser Artikel zeigt, wie man mit IronPDF PDF-Dateien erstellt. Sie benötigen Grundkenntnisse in Visual Studio oder C# sowie praktische HTML-Kenntnisse.

Sie benötigen Visual Studio zum Schreiben, Kompilieren und Ausführen von Anwendungen, C# für Logik und Code sowie HTML zum Formatieren von PDF-Dateien, einschließlich Titeln, Überschriften, Bildern und Absätzen. IronPDF unterstützt .NET Core , .NET 5, Framework und Standard vollständig. Für ASP.NET Anwendungen bietet IronPDF eine reibungslose Integration zur Konvertierung von Webseiten in PDFs.

Mit grundlegenden C#- und HTML-Kenntnissen lassen sich PDF-Dateien in C# mit minimalem Code erstellen. Mehr dazu erfahren Sie auf der offiziellen IronPDF -Funktionsseite . Für die programmatische PDF-Erstellung bietet IronPDF weit mehr als nur die einfache HTML-Konvertierung.

Wie installiere ich IronPDF in meinem .NET-Projekt?

Für die Entwicklung von Lösungen ist die Installation des IronPDF NuGet Pakets erforderlich. Klicken Sie in der Menüleiste auf "Projekt". Wählen Sie im Dropdown-Menü " NuGet Pakete verwalten" aus. Eine detaillierte Anleitung finden Sie in der Installationsübersicht . In diesem Fenster wird Folgendes angezeigt:

NuGet Package Manager window in Visual Studio showing no search results for IronPDF package

Die NuGet Paket-Manager-Schnittstelle zeigt ein leeres Suchergebnis, wenn nach IronPDF gesucht wird, was darauf hinweist, dass das Paket eventuell nicht verfügbar ist oder es Verbindungsprobleme geben könnte.

Wählen Sie "Durchsuchen", um dieses Fenster anzuzeigen:

NuGet Package Manager interface in Visual Studio showing popular .NET packages including Entity Framework Core, Newtonsoft.Json, and Microsoft.Extensions.`DependencyInjection` with their version numbers and download counts.

Der NuGet -Paketmanager bietet einfachen Zugriff auf wichtige .NET -Bibliotheken. Entity Framework Core und Newtonsoft.Json gehören zu den beliebtesten Paketen für Datenbankoperationen bzw. die Verarbeitung von JSON-Daten.

Geben Sie 'IronPDF' in das Suchfeld ein und drücken Sie 'Enter.' Für erweiterte Installationsoptionen, einschließlich plattformspezifischer Konfigurationen, beachten Sie die Dokumentation. Das solltest du sehen:

NuGet Package Manager showing search results for IronPDF packages, including the main IronPDF library with 1.87M downloads and related rendering assets packages.

Die Benutzeroberfläche des NuGet Paketmanagers zeigt verschiedene IronPDF Pakete an, die zur Installation verfügbar sind, wobei die Downloadzahlen und Versionsnummern für jedes Paket angezeigt werden.

Wählen Sie IronPDF:

NuGet Package Manager showing IronPDF installation options alongside competing PDF libraries including PDFCore and other IronPDF rendering packages

Die Benutzeroberfläche des NuGet -Paketmanagers zeigt IronPDF (Version 2021.3.1) als ausgewähltes Paket zur Installation an. Zum Vergleich werden alternative PDF-Bibliotheken aufgelistet, darunter PDFCore und verschiedene IronPDF Rendering-Assets.

Klicken Sie auf "Installieren". Nach erfolgreicher Installation wird Folgendes angezeigt:

Visual Studio dialog showing IronPDF package installation with dependencies including IronPDF.2021.3.1 and related packages.

Der Installationsprozess von IronPDF in Visual Studio zeigt, wie der NuGet -Paketmanager IronPDF Version 2021.3.1 zusammen mit seinen Abhängigkeiten installiert.

Drücken Sie "OK", um die Installation abzuschließen. IronPDF unterstützt Windows-Plattformen , einschließlich Windows 10, 11 und Server-Versionen. Die Bibliothek unterstützt außerdem Linux und macOS für die plattformübergreifende Entwicklung.

Wie erstelle ich PDFs mit IronPDF?

Fügen Sie den IronPDF-Namespace am Anfang der Datei hinzu. Für VB.NET-Entwickler steht ähnliche Funktionalität zur Verfügung:

using IronPdf;
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Sie benötigen einen Dateipfad, um die erstellte PDF-Datei zu speichern. Verwenden Sie SaveFileDialog, um Benutzer zur Eingabe von Dateiname und Pfad aufzufordern. Für fortgeschrittene Szenarien können PDFs ohne Speicherung auf der Festplatte in Speicherstreams exportiert werden :

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!");
    }
}
Private Sub Save_Click(ByVal sender As Object, ByVal e As EventArgs)
	' Code to Select the folder and save the file.
	Dim saveFileDialog1 As 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 Then
		Dim filename As String = saveFileDialog1.FileName
		' actual code that will create Pdf files
		Dim HtmlLine = New HtmlToPdf()
		HtmlLine.RenderHtmlAsPdf(PdfText.Text).SaveAs(filename)
		' MessageBox to display that file save
		MessageBox.Show("File Saved Successfully!")
	End If
End Sub
$vbLabelText   $csharpLabel

SaveFileDialog öffnet ein Dialogfeld zur Auswahl von Ordner und Dateiname. Das Standardverzeichnis ist Laufwerk D, Sie können es aber ändern. DefaultExtension wird auf PDF gesetzt. Eine vollständige Übersicht der Konvertierungsoptionen finden Sie im Tutorial "HTML zu PDF" .

Die "if"-Bedingung enthält Code, der die PDF-Datei erzeugt. Sie können PDFs mit nur zwei Codezeilen generieren. PdfText ist der Name des Rich Text-Feldes, das den PDF-Inhalt enthält. Der Dateiname ist der ausgewählte Dateipfad von SaveFileDialog. Für Webanwendungen unterstützt IronPDF die Konvertierung von URLs in PDFs und von ASPX in PDFs .

Wie lese ich PDFs mit IronPDF?

Mit IronPDF lassen sich PDF-Dateien mit nur zwei Codezeilen lesen. Für fortgeschrittene Extraktionsmethoden siehe den Leitfaden zum Extrahieren von Text und Bildern .

Fügen Sie diese Importe hinzu:

using IronPdf;
using System;
using System.Windows.Forms;
using IronPdf;
using System;
using System.Windows.Forms;
Imports IronPdf
Imports System
Imports System.Windows.Forms
$vbLabelText   $csharpLabel

Schreiben Sie diesen Code in Ihre Funktion. IronPDF bietet Funktionen zum Parsen von PDFs und zum Zugriff auf das PDF-DOM :

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
$vbLabelText   $csharpLabel

Dadurch werden alle Informationen aus den Dokumenten für die Betrachter extrahiert. Die Berichtskomponenten nutzen diese Daten als Datenquellen. IronPDF unterstützt das Lesen von PDFs aus Speicherströmen und das Konvertieren von PDFs in HTML für die Webdarstellung.

Welche Funktionen bietet GrapeCity PDF?

GrapeCity Documents bietet plattformübergreifendes Dokumentenmanagement für gängige Formate. Die .NET Standard 2.0-Bibliothek liest, generiert, ändert und speichert PDFs ohne Adobe Acrobat. Es bietet Unterstützung für Schriftarten, Bilder, Grafiken, Barcodes, Kommentare, Konturen, Stempel und Wasserzeichen.

Welche PDF-Bearbeitungsfunktionen stehen zur Verfügung?

GrapeCityPDF erstellt PDFs für einfache oder komplexe Geschäftsanforderungen in .NET Standard-Apps. Sie können PDFs aus jeder Quelle laden, ändern und speichern. IronPDF bietet eine vollständige PDF-Bearbeitung, einschließlich des Zusammenführens/Aufteilens von PDFs , des Hinzufügens/Entfernens von Seiten und des Drehens von Seiten .

Kann ich PDFs in Bilder konvertieren?

GrapeCityPDF speichert PDFs als Bilder ohne Qualitätsverlust mit minimalem Code. IronPDF bietet die Funktion "PDF in Bilder rastern" und unterstützt dabei die Formate PNG, JPEG und TIFF.

Enthält GrapeCity eine PDF-Viewer-Komponente?

GrapeCity Documents PDF Viewer ist ein leichtgewichtiger clientseitiger Viewer, der Standard-PDF-Funktionen unterstützt. Für .NET MAUI Entwickler bietet IronPDF die Möglichkeit , PDFs in MAUI-Anwendungen mit Navigations- und Suchfunktionen anzuzeigen .

Welche Funktionen werden unterstützt?

GrapeCityPDF erstellt komplexe PDFs mit Text, Grafiken, Fotos, Anmerkungen und Gliederungen. IronPDF erweitert diese Funktionen um digitale Signaturen , Formularerstellung/-ausfüllung , Wasserzeichen und Metadatenverwaltung .

Wie installiere ich GrapeCity PDF?

Es gibt zwei Installationsmethoden. Für die containerisierte Bereitstellung bietet IronPDF Docker-Unterstützung und Remote-Containerbetrieb für eine flexible Generierung:

  1. Laden Sie die gezippten Quelldateien herunter.
  2. Dateien in ein Verzeichnis extrahieren.
  3. Gehen Sie zu diesem Verzeichnis.
  4. Führen Sie run.cmd aus, um Beispiele zu erstellen, den SupportApi-Dienst zu starten und http://localhost:3003 zu öffnen.
  5. Siehe readme.MD für Details.

Wie installiere ich die WinForms-Edition?

Befolgen Sie diese Schritte zur Installation der WinForms-Edition:

  • Download C1ControlPanel from GrapeCity's ComponentOne.
  • Öffnen Sie ControlPanel mit ComponentOneC1ControlPanel.exe (schließen Sie Visual Studio).
  • Melden Sie sich mit Ihrer registrierten E-Mail-Adresse und Ihrem Passwort an.
  • Für neue Benutzer:
    • Registrieren Sie sich und erstellen Sie ein Konto.
    • E-Mail-Adresse bestätigen.
    • Aktivierung über den Bestätigungslink.
    • Falls gewünscht, können Sie als anonymer Benutzer fortfahren.
  • Wählen Sie Installieren im Kachelbereich der WinForms-Edition. Installieren Sie alle Editionen über das Kontrollkästchen Alle Editionen.
`ComponentOne` product edition comparison showing six different editions including `WinForms`, WPF, MVC, MVC Core, Wijmo, and UWP editions with their descriptions and install options

`GrapeCity` bietet mit `ComponentOne` mehrere Editionsoptionen, die auf verschiedene Entwicklungsplattformen und Frameworks zugeschnitten sind und jeweils die Möglichkeit bieten, Beispielprojekte zu installieren.

  • Klicken Sie auf "Installieren", um die Lizenzvereinbarung anzuzeigen. Nach Prüfung annehmen.
  • Um die Einstellungsseite anzuzeigen, müssen Sie die Lizenzvereinbarung akzeptieren. Überprüfen Sie den Verzeichnispfad und beginnen Sie mit der Installation.
`ComponentOne` installation settings screen showing installation directory, samples directory, and options to join customer experience program and send system information

`ComponentOne` Installationskonfigurationsbildschirm mit Datenschutz- und Datenerfassungsoptionen

  • Der Installateur zeigt den Fortschritt während der Steuerungsinstallation an. Ein Abbruch während dieses Vorgangs ist nicht möglich.
  • Nach Abschluss der Installation erscheint die Meldung "Installation erfolgreich". Zeigt die aktuell installierte Version an.
`WinForms` Edition installation dialog showing download progress and install button for 65+ UI controls

Die Installationsoberfläche `WinForms` Edition zeigt eine einfache Download-Fortschrittsanzeige und eine Installationsoption für eine Suite von über 65 intelligenten und effektiven UI-Steuerelementen, die für die schnelle Entwicklung von Windows Forms konzipiert wurden.

`ComponentOne` installation success screen showing version 20183.1.338 with View Log and Back buttons

Die Installationsoberfläche `ComponentOne` zeigt eine Erfolgsmeldung für die Version 20183.1.338 an und enthält Navigationsregisterkarten für Produkte, Aktivitäten, Lizenz und Support.

Wie erstelle ich PDFs mit GrapeCity?

Der folgende Code demonstriert die grundlegende GrapeCity PDF-Erstellung. Für erweiterte Funktionen wie HTML-zu-PDF mit JavaScript , responsivem CSS oder benutzerdefinierten Kopf- und Fußzeilen bietet IronPDF Komplettlösungen:

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);
        }
    }
}
Imports Microsoft.VisualBasic
Imports System
Imports System.IO
Imports System.Drawing
Imports System.Text
Imports GrapeCity.Documents.Text
Imports GrapeCity.Documents.Common
Imports GrapeCity.Documents.Drawing
Imports GrapeCity.Documents.Pdf
Imports GrapeCity.Documents.Pdf.Structure
Imports GrapeCity.Documents.Pdf.MarkedContent
Imports GrapeCity.Documents.Pdf.Graphics
Imports GrapeCity.Documents.Pdf.Annotations
Imports GCTEXT = GrapeCity.Documents.Text
Imports GCDRAW = GrapeCity.Documents.Drawing
Namespace GcPdfWeb.Samples.Basics
	' This sample shows how to create a PDF/A-3u compliant document.
	Public Class PdfA
		Public Sub CreatePDF(ByVal stream As Stream)
			Dim doc = New GcPdfDocument()
			Dim [date] = New DateTime(1961, 4, 12, 6, 7, 0, DateTimeKind.Utc)

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

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

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

			Dim tl As TextLayout = Nothing
			' Add 3 pages with sample content tagged according to PDF/A rules:
			For pageNo As Integer = 1 To 3
				' add page
				Dim page = doc.Pages.Add()
				Dim g = page.Graphics
				Dim y As Single = 72
				If doc.Pages.Count = 1 Then
					' Create paragraph element:
					Dim seParagraph = New StructElement("P") With {.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))
				End If

				' Add some sample paragraphs tagged according to PDF/A rules:
				For i As Integer = 1 To 3
					' Create paragraph element:
					Dim seParagraph = New StructElement("P") With {.DefaultPage = page}
					' Add it to Part element:
					sePart.Children.Add(seParagraph)

					Dim sb = New StringBuilder()
					sb.Append(String.Format("Paragraph {0} on page {1}: ", i, pageNo))
					sb.Append(Common.Util.LoremIpsum(1, 2, 4, 5, 10))
					Dim 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:
					Dim 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"
					Dim fn = String.Format("Page{0}_Paragraph{1}.txt", pageNo, i)
					Dim 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)
				Next i
			Next pageNo

			' PDF/A-3 allows transparency drawing in PDF file, add some:
			Dim 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:
			Dim r = New RectangleF(0, 0, 144, 72)
			Dim fxo = New FormXObject(doc, r)
			Dim gfxo = fxo.Graphics
			gfxo.FillRectangle(r, Color.FromArgb(40, Color.Violet))
			Dim tf As New TextFormat() With {
				.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), Nothing, ImageAlign.ScaleImage)

			' PDF/A-3 allows using embedded files, but each embedded file must be associated with a document's element:
			Dim ef As EmbeddedFileStream = 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"
			Dim 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:
			Dim sa = New StampAnnotation() With {
				.UserName = "Minerva",
				.Font = fnt,
				.Rect = New RectangleF(300, 36, 220, 72)
			}
			sa.Flags = sa.Flags Or AnnotationFlags.Print
			' Use a FormXObject to represent the stamp annotation:
			Dim stampFxo = New FormXObject(doc, New RectangleF(PointF.Empty, sa.Rect.Size))
			Dim gstampFxo = stampFxo.Graphics
			gstampFxo.FillRectangle(stampFxo.Bounds, Color.FromArgb(40, Color.Green))
			gstampFxo.DrawString("Stamp Annotation" & vbLf & "associated 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)
		End Sub
	End Class
End Namespace
$vbLabelText   $csharpLabel

GrapeCityPDF bietet im Vergleich zu IronPDF eingeschränkte Funktionen. IronPDF unterstützt PDF/A-Konformität , PDF/UA-Barrierefreiheit , benutzerdefinierte Papierformate und erweiterte Rendering-Optionen .

Welche Lizenzmodelle und Preise bietet IronPDF an?

Die 30-Tage-Geld-zurück-Garantie: Nach dem Kauf der Lizenz erhalten Sie eine 30-Tage-Geld-zurück-Garantie. Wenn die Lizenz nicht gut zu Ihren Bedürfnissen passt, garantiert Ihnen IronPDF Ihr Geld innerhalb von 30 Tagen zurück.

Einfache Integration: Die Integration von IronPDF in ein laufendes Projekt und Ihre Umgebung ist ein nahtloser Prozess, der mit nur einer einzigen Codezeile abgeschlossen wird. Dies kann erreicht werden, wenn Sie die NuGet-Paket-Methode zur Integration verwenden oder direkt online herunterladen und in Ihre Umgebung integrieren.

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

Kostenloser Support und Produktaktualisierungen: Jede Lizenz beinhaltet umfassenden Support direkt vom Entwicklerteam sowie ein Jahr lang kostenlose Produktaktualisierungen. Es ist möglich, Erweiterungen jederzeit zu kaufen. Erweiterungen können vor dem Kauf eingesehen werden.

Sofortige Lizenzen: Sobald die Zahlung eingegangen ist, werden die registrierten Lizenzschlüssel versendet.

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

Wie unterstützt IronPDF moderne Web-Frameworks wie Bootstrap?

Die moderne PDF-Erstellung profitiert von visuellen Prozessdarstellungen. Dieses Bootstrap 5-Beispiel demonstriert die Fähigkeit von IronPDF, Workflow-Zeitachsen mit Karten, Abzeichen und Schrittanzeigen darzustellen. Vollständige Unterstützung für das Framework finden Sie im Bootstrap & Flexbox-Leitfaden zur Fehlerbehebung :

using IronPdf;

var renderer = new ChromePdfRenderer();

string workflowTimeline = @"
<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8'>
    <link href='___PROTECTED_URL_66___ rel='stylesheet'>
    <style>
        .timeline-item { position: relative; padding-left: 40px; margin-bottom: 30px; }
        .timeline-item::before { content: ''; position: absolute; left: 0; top: 0; width: 20px; height: 20px;
            background: #0d6efd; border-radius: 50%; border: 3px solid white; box-shadow: 0 0 0 2px #0d6efd; }
        .timeline-item::after { content: ''; position: absolute; left: 9px; top: 20px; width: 2px; height: calc(100% + 10px);
            background: #dee2e6; }
        .timeline-item:last-child::after { display: none; }
        @media print { .timeline-item { page-break-inside: avoid; } }
    </style>
</head>
<body class='bg-light'>
    <div class='container py-4'>
        <div class='text-center mb-5'>
            <h1 class='display-6 fw-bold'>PDF Generation Workflow</h1>
            <p class='lead text-muted'>From HTML to Professional PDF Documents</p>
        </div>

        <div class='timeline-item'>
            <div class='card shadow-sm'>
                <div class='card-body'>
                    <div class='d-flex justify-content-between align-items-center mb-2'>
                        <h4 class='card-title mb-0'>Step 1: Initialize Renderer</h4>
                        <span class='badge bg-primary'>Setup</span>
                    </div>
                    <p class='card-text'>Create ChromePdfRenderer instance with Chrome V8 engine for accurate HTML rendering.</p>
                    <div class='bg-light p-2 rounded'>
                        <code>var renderer = new ChromePdfRenderer();</code>
                    </div>
                    <div class='mt-2'>
                        <small class='text-muted'>✓ Chrome V8 Engine • ✓ Full CSS3 Support • ✓ JavaScript Ready</small>
                    </div>
                </div>
            </div>
        </div>

        <div class='timeline-item'>
            <div class='card shadow-sm'>
                <div class='card-body'>
                    <div class='d-flex justify-content-between align-items-center mb-2'>
                        <h4 class='card-title mb-0'>Step 2: Prepare HTML Content</h4>
                        <span class='badge bg-info'>Content</span>
                    </div>
                    <p class='card-text'>Design your document using modern HTML5, CSS3 (Flexbox/Grid), and optional JavaScript.</p>
                    <div class='row g-2'>
                        <div class='col-4'><span class='badge bg-success w-100'>HTML5</span></div>
                        <div class='col-4'><span class='badge bg-success w-100'>CSS3</span></div>
                        <div class='col-4'><span class='badge bg-success w-100'>JavaScript</span></div>
                    </div>
                </div>
            </div>
        </div>

        <div class='timeline-item'>
            <div class='card shadow-sm'>
                <div class='card-body'>
                    <div class='d-flex justify-content-between align-items-center mb-2'>
                        <h4 class='card-title mb-0'>Step 3: Render to PDF</h4>
                        <span class='badge bg-warning text-dark'>Processing</span>
                    </div>
                    <p class='card-text'>Convert HTML to PDF with pixel-perfect accuracy and fast performance.</p>
                    <div class='bg-light p-2 rounded'>
                        <code>var pdf = renderer.RenderHtmlAsPdf(htmlContent);</code>
                    </div>
                    <div class='progress mt-2' style='height: 8px;'>
                        <div class='progress-bar bg-warning' style='width: 100%'></div>
                    </div>
                </div>
            </div>
        </div>

        <div class='timeline-item'>
            <div class='card shadow-sm'>
                <div class='card-body'>
                    <div class='d-flex justify-content-between align-items-center mb-2'>
                        <h4 class='card-title mb-0'>Step 4: Save or Stream</h4>
                        <span class='badge bg-success'>Output</span>
                    </div>
                    <p class='card-text'>Export to file, stream, or byte array for flexible deployment options.</p>
                    <div class='bg-light p-2 rounded'>
                        <code>pdf.SaveAs("document.pdf");</code>
                    </div>
                    <div class='mt-2'>
                        <span class='badge bg-outline-secondary me-1'>File</span>
                        <span class='badge bg-outline-secondary me-1'>Stream</span>
                        <span class='badge bg-outline-secondary'>Byte Array</span>
                    </div>
                </div>
            </div>
        </div>

        <div class='alert alert-info'>
            <strong>Comparison Note:</strong> GrapeCity PDF Viewer focuses on document viewing and annotation, not HTML-to-PDF generation. IronPDF specializes in creating PDFs from modern web content with full Bootstrap and framework support.
        </div>

        <div class='card shadow-sm border-primary'>
            <div class='card-header bg-primary text-white'>
                <h5 class='mb-0'>Key Advantages</h5>
            </div>
            <div class='card-body'>
                <div class='row'>
                    <div class='col-md-6'>
                        <h6 class='text-primary'>IronPDF Strengths</h6>
                        <ul class='small'>
                            <li>Complete HTML-to-PDF workflow</li>
                            <li>Bootstrap 5 framework support</li>
                            <li>Async/await for scalability</li>
                            <li>Cross-platform deployment</li>
                        </ul>
                    </div>
                    <div class='col-md-6'>
                        <h6 class='text-muted'>GrapeCity Focus</h6>
                        <ul class='small'>
                            <li>PDF viewing and annotation</li>
                            <li>UI component for display</li>
                            <li>Limited generation features</li>
                            <li>Viewer-centric approach</li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </div>
</body>
</html>";

var pdf = renderer.RenderHtmlAsPdf(workflowTimeline);
pdf.SaveAs("workflow-timeline.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

string workflowTimeline = @"
<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8'>
    <link href='___PROTECTED_URL_66___ rel='stylesheet'>
    <style>
        .timeline-item { position: relative; padding-left: 40px; margin-bottom: 30px; }
        .timeline-item::before { content: ''; position: absolute; left: 0; top: 0; width: 20px; height: 20px;
            background: #0d6efd; border-radius: 50%; border: 3px solid white; box-shadow: 0 0 0 2px #0d6efd; }
        .timeline-item::after { content: ''; position: absolute; left: 9px; top: 20px; width: 2px; height: calc(100% + 10px);
            background: #dee2e6; }
        .timeline-item:last-child::after { display: none; }
        @media print { .timeline-item { page-break-inside: avoid; } }
    </style>
</head>
<body class='bg-light'>
    <div class='container py-4'>
        <div class='text-center mb-5'>
            <h1 class='display-6 fw-bold'>PDF Generation Workflow</h1>
            <p class='lead text-muted'>From HTML to Professional PDF Documents</p>
        </div>

        <div class='timeline-item'>
            <div class='card shadow-sm'>
                <div class='card-body'>
                    <div class='d-flex justify-content-between align-items-center mb-2'>
                        <h4 class='card-title mb-0'>Step 1: Initialize Renderer</h4>
                        <span class='badge bg-primary'>Setup</span>
                    </div>
                    <p class='card-text'>Create ChromePdfRenderer instance with Chrome V8 engine for accurate HTML rendering.</p>
                    <div class='bg-light p-2 rounded'>
                        <code>var renderer = new ChromePdfRenderer();</code>
                    </div>
                    <div class='mt-2'>
                        <small class='text-muted'>✓ Chrome V8 Engine • ✓ Full CSS3 Support • ✓ JavaScript Ready</small>
                    </div>
                </div>
            </div>
        </div>

        <div class='timeline-item'>
            <div class='card shadow-sm'>
                <div class='card-body'>
                    <div class='d-flex justify-content-between align-items-center mb-2'>
                        <h4 class='card-title mb-0'>Step 2: Prepare HTML Content</h4>
                        <span class='badge bg-info'>Content</span>
                    </div>
                    <p class='card-text'>Design your document using modern HTML5, CSS3 (Flexbox/Grid), and optional JavaScript.</p>
                    <div class='row g-2'>
                        <div class='col-4'><span class='badge bg-success w-100'>HTML5</span></div>
                        <div class='col-4'><span class='badge bg-success w-100'>CSS3</span></div>
                        <div class='col-4'><span class='badge bg-success w-100'>JavaScript</span></div>
                    </div>
                </div>
            </div>
        </div>

        <div class='timeline-item'>
            <div class='card shadow-sm'>
                <div class='card-body'>
                    <div class='d-flex justify-content-between align-items-center mb-2'>
                        <h4 class='card-title mb-0'>Step 3: Render to PDF</h4>
                        <span class='badge bg-warning text-dark'>Processing</span>
                    </div>
                    <p class='card-text'>Convert HTML to PDF with pixel-perfect accuracy and fast performance.</p>
                    <div class='bg-light p-2 rounded'>
                        <code>var pdf = renderer.RenderHtmlAsPdf(htmlContent);</code>
                    </div>
                    <div class='progress mt-2' style='height: 8px;'>
                        <div class='progress-bar bg-warning' style='width: 100%'></div>
                    </div>
                </div>
            </div>
        </div>

        <div class='timeline-item'>
            <div class='card shadow-sm'>
                <div class='card-body'>
                    <div class='d-flex justify-content-between align-items-center mb-2'>
                        <h4 class='card-title mb-0'>Step 4: Save or Stream</h4>
                        <span class='badge bg-success'>Output</span>
                    </div>
                    <p class='card-text'>Export to file, stream, or byte array for flexible deployment options.</p>
                    <div class='bg-light p-2 rounded'>
                        <code>pdf.SaveAs("document.pdf");</code>
                    </div>
                    <div class='mt-2'>
                        <span class='badge bg-outline-secondary me-1'>File</span>
                        <span class='badge bg-outline-secondary me-1'>Stream</span>
                        <span class='badge bg-outline-secondary'>Byte Array</span>
                    </div>
                </div>
            </div>
        </div>

        <div class='alert alert-info'>
            <strong>Comparison Note:</strong> GrapeCity PDF Viewer focuses on document viewing and annotation, not HTML-to-PDF generation. IronPDF specializes in creating PDFs from modern web content with full Bootstrap and framework support.
        </div>

        <div class='card shadow-sm border-primary'>
            <div class='card-header bg-primary text-white'>
                <h5 class='mb-0'>Key Advantages</h5>
            </div>
            <div class='card-body'>
                <div class='row'>
                    <div class='col-md-6'>
                        <h6 class='text-primary'>IronPDF Strengths</h6>
                        <ul class='small'>
                            <li>Complete HTML-to-PDF workflow</li>
                            <li>Bootstrap 5 framework support</li>
                            <li>Async/await for scalability</li>
                            <li>Cross-platform deployment</li>
                        </ul>
                    </div>
                    <div class='col-md-6'>
                        <h6 class='text-muted'>GrapeCity Focus</h6>
                        <ul class='small'>
                            <li>PDF viewing and annotation</li>
                            <li>UI component for display</li>
                            <li>Limited generation features</li>
                            <li>Viewer-centric approach</li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </div>
</body>
</html>";

var pdf = renderer.RenderHtmlAsPdf(workflowTimeline);
pdf.SaveAs("workflow-timeline.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

Dim workflowTimeline As String = "
<!DOCTYPE html>
<html>
<head>
    <meta charset='utf-8'>
    <link href='___PROTECTED_URL_66___ rel='stylesheet'>
    <style>
        .timeline-item { position: relative; padding-left: 40px; margin-bottom: 30px; }
        .timeline-item::before { content: ''; position: absolute; left: 0; top: 0; width: 20px; height: 20px;
            background: #0d6efd; border-radius: 50%; border: 3px solid white; box-shadow: 0 0 0 2px #0d6efd; }
        .timeline-item::after { content: ''; position: absolute; left: 9px; top: 20px; width: 2px; height: calc(100% + 10px);
            background: #dee2e6; }
        .timeline-item:last-child::after { display: none; }
        @media print { .timeline-item { page-break-inside: avoid; } }
    </style>
</head>
<body class='bg-light'>
    <div class='container py-4'>
        <div class='text-center mb-5'>
            <h1 class='display-6 fw-bold'>PDF Generation Workflow</h1>
            <p class='lead text-muted'>From HTML to Professional PDF Documents</p>
        </div>

        <div class='timeline-item'>
            <div class='card shadow-sm'>
                <div class='card-body'>
                    <div class='d-flex justify-content-between align-items-center mb-2'>
                        <h4 class='card-title mb-0'>Step 1: Initialize Renderer</h4>
                        <span class='badge bg-primary'>Setup</span>
                    </div>
                    <p class='card-text'>Create ChromePdfRenderer instance with Chrome V8 engine for accurate HTML rendering.</p>
                    <div class='bg-light p-2 rounded'>
                        <code>var renderer = new ChromePdfRenderer();</code>
                    </div>
                    <div class='mt-2'>
                        <small class='text-muted'>✓ Chrome V8 Engine • ✓ Full CSS3 Support • ✓ JavaScript Ready</small>
                    </div>
                </div>
            </div>
        </div>

        <div class='timeline-item'>
            <div class='card shadow-sm'>
                <div class='card-body'>
                    <div class='d-flex justify-content-between align-items-center mb-2'>
                        <h4 class='card-title mb-0'>Step 2: Prepare HTML Content</h4>
                        <span class='badge bg-info'>Content</span>
                    </div>
                    <p class='card-text'>Design your document using modern HTML5, CSS3 (Flexbox/Grid), and optional JavaScript.</p>
                    <div class='row g-2'>
                        <div class='col-4'><span class='badge bg-success w-100'>HTML5</span></div>
                        <div class='col-4'><span class='badge bg-success w-100'>CSS3</span></div>
                        <div class='col-4'><span class='badge bg-success w-100'>JavaScript</span></div>
                    </div>
                </div>
            </div>
        </div>

        <div class='timeline-item'>
            <div class='card shadow-sm'>
                <div class='card-body'>
                    <div class='d-flex justify-content-between align-items-center mb-2'>
                        <h4 class='card-title mb-0'>Step 3: Render to PDF</h4>
                        <span class='badge bg-warning text-dark'>Processing</span>
                    </div>
                    <p class='card-text'>Convert HTML to PDF with pixel-perfect accuracy and fast performance.</p>
                    <div class='bg-light p-2 rounded'>
                        <code>var pdf = renderer.RenderHtmlAsPdf(htmlContent);</code>
                    </div>
                    <div class='progress mt-2' style='height: 8px;'>
                        <div class='progress-bar bg-warning' style='width: 100%'></div>
                    </div>
                </div>
            </div>
        </div>

        <div class='timeline-item'>
            <div class='card shadow-sm'>
                <div class='card-body'>
                    <div class='d-flex justify-content-between align-items-center mb-2'>
                        <h4 class='card-title mb-0'>Step 4: Save or Stream</h4>
                        <span class='badge bg-success'>Output</span>
                    </div>
                    <p class='card-text'>Export to file, stream, or byte array for flexible deployment options.</p>
                    <div class='bg-light p-2 rounded'>
                        <code>pdf.SaveAs(""document.pdf"");</code>
                    </div>
                    <div class='mt-2'>
                        <span class='badge bg-outline-secondary me-1'>File</span>
                        <span class='badge bg-outline-secondary me-1'>Stream</span>
                        <span class='badge bg-outline-secondary'>Byte Array</span>
                    </div>
                </div>
            </div>
        </div>

        <div class='alert alert-info'>
            <strong>Comparison Note:</strong> GrapeCity PDF Viewer focuses on document viewing and annotation, not HTML-to-PDF generation. IronPDF specializes in creating PDFs from modern web content with full Bootstrap and framework support.
        </div>

        <div class='card shadow-sm border-primary'>
            <div class='card-header bg-primary text-white'>
                <h5 class='mb-0'>Key Advantages</h5>
            </div>
            <div class='card-body'>
                <div class='row'>
                    <div class='col-md-6'>
                        <h6 class='text-primary'>IronPDF Strengths</h6>
                        <ul class='small'>
                            <li>Complete HTML-to-PDF workflow</li>
                            <li>Bootstrap 5 framework support</li>
                            <li>Async/await for scalability</li>
                            <li>Cross-platform deployment</li>
                        </ul>
                    </div>
                    <div class='col-md-6'>
                        <h6 class='text-muted'>GrapeCity Focus</h6>
                        <ul class='small'>
                            <li>PDF viewing and annotation</li>
                            <li>UI component for display</li>
                            <li>Limited generation features</li>
                            <li>Viewer-centric approach</li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </div>
</body>
</html>"

Dim pdf = renderer.RenderHtmlAsPdf(workflowTimeline)
pdf.SaveAs("workflow-timeline.pdf")
$vbLabelText   $csharpLabel

Ergebnis: Ein Professional Workflow-Timeline-PDF mit Bootstrap 5-Karten, Badges, Fortschrittsbalken und benutzerdefiniertem Timeline-Styling. IronPDF rendert präzise alle Positionierungen, Flexbox-Layouts und Dienstprogrammfunktionen und demonstriert umfassende CSS3-Unterstützung für komplexe visuelle Designs.

Ausführliche Informationen zur Bootstrap-Kompatibilität finden Sie im Bootstrap & Flexbox CSS Guide . IronPDF unterstützt Webfonts und Icons für eine ansprechende Typografie.

Wie hoch sind die Preise für das Lite Paket?

  • 1 Entwickler
  • 1 Standort
  • 1 Projekt
  • Unbefristete Lizenz

Dieses Paket ermöglicht es einem Entwickler , Iron Software an einem Ort für eine einzelne Anwendung zu nutzen. Lizenzen sind außerhalb von Organisationen oder Agentur-/Kundenbeziehungen nicht übertragbar. Ausgenommen sind die Weiterverbreitung durch OEMs und die Nutzung von SaaS ohne zusätzliche Deckung.

Preisgestaltung: beginnt bei $999 pro Jahr.

Was beinhaltet die Professional ?

  • 10 Entwickler
  • 10 Standorte
  • 10 Projekte
  • Unbefristete Lizenz

Diese Lizenz erlaubt zehn Entwicklern die Nutzung der Iron Software an bis zu zehn Standorten. Sie können es auf unbegrenzt vielen Websites, Intranet-Anwendungen oder Desktop-Software verwenden. Lizenzen sind nicht auf andere Organisationen übertragbar. Ausgenommen sind die Weiterverbreitung durch OEMs und die Nutzung von SaaS ohne zusätzliche Deckung. Lässt sich in bis zu 10 Projekte integrieren.

Preisgestaltung: Beginnt bei $1,499 pro Jahr.

Welche Vorteile bietet eine unbegrenzte Lizenz?

  • Unbegrenzte Entwickler
  • Unbegrenzte Standorte
  • Unbegrenzte Projekte
  • Unbefristete Lizenz

Ermöglicht es einer unbegrenzten Anzahl von Entwicklern innerhalb einer Organisation, die Iron Software an einer unbegrenzten Anzahl von Standorten zu nutzen. Unbegrenzte Anwendungsmöglichkeiten. Lizenzen sind nicht auf andere Organisationen übertragbar. Ausgenommen sind die Weiterverbreitung durch OEMs und die Nutzung von SaaS ohne zusätzliche Deckung.

Preisgestaltung: Beginnt bei $2,399 pro Jahr.

Lizenzgebührenfreie Weiterverbreitung: Dies erlaubt Ihnen, die Iron Software als Teil mehrerer unterschiedlich verpackter kommerzieller Produkte zu vertreiben (ohne Lizenzgebühren zahlen zu müssen), basierend auf der Anzahl der Projekte, die von der Basislizenz abgedeckt werden. Dies ermöglicht den Einsatz von Iron Software innerhalb von SaaS-Softwarediensten, die auf der Anzahl der durch die Basislizenz abgedeckten Projekte basieren.

IronPDF pricing tiers comparison showing Lite, Professional, and Unlimited licenses with different developer, location, and project limits

IronPDF bietet mehrere Lizenzstufen, um den individuellen Entwickler, Teams und Unternehmensbereitstellungen gerecht zu werden. Besuchen Sie die IronPDF Lizenzierungsseite für aktuelle Preise.

Was sind die Lizenzmodelle und die Preisgestaltung von GrapeCity PDF?

Was beinhalten die Dokumente für die PDF-Lizenz?

  • Beinhaltet 1 Entwicklerlizenz
  • 1 Lieferort

Beinhaltet eine Entwicklerlizenz und einen Vertriebsstandort ohne Support und Wartung.

Für aktuelle Preise besuchen Sie direkt die MESCIUS (vormals GrapeCity) Webseite, da die Preise abonnementsbasiert sind und sich ändern können.

Was ist Documents for PDF Unlimited?

  • Beinhaltet 1 Entwicklerlizenz
  • Unbegrenzte Versandorte

Beinhaltet eine Entwicklerlizenz mit unbegrenzter Vertriebsmöglichkeit. Kein Support und keine Wartung. GrapeCity unterstützt kein SaaS und OEM.

Für aktuelle Preise besuchen Sie direkt die MESCIUS (vormals GrapeCity) Webseite, da die Preise abonnementsbasiert sind und sich ändern können.

Was bietet Documents for PDF Team Unlimited?

  • Beinhaltet 5 Entwicklerlizenzen
  • Unbegrenzte Versandorte

Beinhaltet fünf Entwicklerlizenzen mit unbegrenzter Vertriebsmöglichkeit. Kein Support und keine Wartung. GrapeCity unterstützt kein SaaS und OEM.

Für aktuelle Preise besuchen Sie direkt die MESCIUS (vormals GrapeCity) Webseite, da die Preise abonnementsbasiert sind und sich ändern können.

Three pricing tiers for Documents for PDF software showing basic, Unlimited, and Team Unlimited tiers, each with different license and distribution options.

Die Preisstruktur von `GrapeCity` Documents for PDF bietet drei Stufen, um den unterschiedlichen Größen der Entwicklerteams und den jeweiligen Vertriebsanforderungen gerecht zu werden.

Das IronPDF Lite One-Developer-Paket beinhaltet ein Jahr Unterstützung für $999. MESCIUS (ehemals GrapeCity) Documents für PDF-Preise ist abonnementbasiert – sehen Sie auf der offiziellen MESCIUS-Website die aktuellen Tarife ein. Das IronPDF Professional-Paket umfasst 10 Entwickler mit einjähriger Unterstützung für $1,499. Für weitere Informationen zu IronPDF-Lizenzierungsoptionen besuchen Sie die offizielle Lizenzierungsseite.

Die IronPDF Lite und Professional Pakete beinhalten SaaS-Service, OEM-Lizenz und 5-Jahres-Supportoptionen. Die Lizenzbedingungen von MESCIUS (ehemals GrapeCity) und die SaaS/OEM-Abdeckung variieren – konsultieren Sie die offizielle MESCIUS-Website für Details. Informieren Sie sich über Lizenzverlängerungen und Upgrade-Optionen für langfristigen Support.

Welche PDF-Bibliothek sollte ich für mein .NET -Projekt wählen?

GrapeCity Documents für PDF erlaubt den Export/Import, AcroForms Erstellung und PDF-Ausführung in Desktop-Anwendungen. Für die vollständige PDF-Bearbeitung einschließlich Formularerstellung , digitaler Signaturen und Unterstützung für Anmerkungen bietet IronPDF jedoch erweiterte Funktionen.

IronPDF bietet eine höhere Genauigkeit. Konkurrenten können auf Probleme wie fehlgeschlagene Bildkonvertierung oder unbekannte Zeichen stoßen. IronPDF liefert präzise Ergebnisse. Die Chrome-Rendering-Engine gewährleistet eine pixelgenaue Darstellung, die anhand des Leitfadens "Pixelgenaues HTML zu PDF" verifiziert wurde. Zur Optimierung konsultieren Sie bitte den IronPDF Leistungsleitfaden .

IronPDF bietet wettbewerbsfähige Lizenzen und Support ohne laufende Kosten. IronPDF beginnt bei $999 mit vollständigen Funktionspaketen. MESCIUS (ehemals GrapeCity) PDF verwendet ein abonnementbasiertes Preismodell – konsultieren Sie die offizielle MESCIUS-Website für aktuelle Tarife. IronPDF unterstützt mehrere Plattformen zu einem Preis. Für Enterprise bietet IronPDF asynchrone und Multithreading-Funktionen für eine leistungsstarke Dokumentenerstellung.

Sie können die kostenlose Testversion nutzen, um alle Funktionen kennenzulernen. Mit dem Kauf des kompletten Iron Suite erhalten Sie fünf Produkte zum Preis von zwei. Für Details zur IronPDF Lizenzierung besuchen Sie die Iron Software Iron Suite Produktseite für vollständige Paketinformationen.

Hinweis:GrapeCity Documents für PDF ist ein eingetragenes Warenzeichen seines jeweiligen Eigentümers. Diese Website ist weder mit noch gesponsert oder genehmigt von GrapeCity Documents für PDF. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.

Häufig gestellte Fragen

Wie kann ich HTML in PDF in .NET umwandeln?

Sie können die RenderHtmlAsPdf-Methode von IronPDF verwenden, um HTML-Strings in PDFs zu konvertieren. Zusätzlich können Sie HTML-Dateien mit der RenderHtmlFileAsPdf-Methode in PDFs umwandeln.

Was sind die Installationsschritte für eine PDF-Bibliothek mit NuGet?

Um IronPDF mit NuGet zu installieren, öffnen Sie Visual Studio, navigieren Sie zu 'NuGet-Pakete verwalten', suchen Sie nach 'IronPDF' und klicken Sie auf 'Installieren', um es zu Ihrem Projekt hinzuzufügen.

Was sind einige Alternativen zum GrapeCity PDF Viewer for .NET?

IronPDF ist eine geeignete Alternative zum GrapeCity PDF Viewer und bietet eine benutzerfreundliche Erfahrung mit umfangreicher Unterstützung für .NET Core, .NET 5, Framework und Standard.

Wie erstelle und lese ich PDF-Dateien mit einer .NET-Bibliothek?

Mit IronPDF können Sie PDFs erstellen, indem Sie den IronPDF-Namespace einfügen und die HtmlToPdf-Klasse verwenden, um HTML als PDF zu rendern. Zum Lesen von PDFs können Sie die PdfDocument-Klasse verwenden, um auf den Inhalt zuzugreifen und ihn zu bearbeiten.

Welche Lizenzierungsoptionen stehen für eine PDF-Bibliothek zur Verfügung?

IronPDF bietet eine Reihe von Lizenzoptionen an, einschließlich eines Lite-Pakets für Einzelentwickler, einer Professional-Lizenz für bis zu 10 Entwickler und einer unbegrenzten Lizenz für Teams, alle mit perpetueller Lizenzierung und Unterstützungsoptionen.

Warum sollte ich IronPDF gegenüber anderen PDF-Lösungen wählen?

IronPDF wird empfohlen für seine Genauigkeit, umfassenden Funktionen, wettbewerbsfähige Lizenzierung und umfangreiche Support-Optionen. Es bietet Unterstützung für mehrere Plattformen zu einem wettbewerbsfähigen Preis.

Kann ich eine PDF-Bibliothek vor dem Kauf ausprobieren?

Ja, IronPDF bietet eine kostenlose Testversion, die Ihnen ermöglicht, alle verfügbaren Funktionen zu erkunden, bevor Sie eine Kaufentscheidung treffen. Darüber hinaus bietet das Iron Suite-Paket Zugang zu allen Iron Software-Produkten zu einem reduzierten Preis.

Was sind einige Nachteile der Verwendung von PDF-Dateien?

PDFs können aufgrund ihrer Größe schwer per E-Mail zu teilen sein, möglicherweise nicht klar auf mobilen Geräten angezeigt werden im Vergleich zu Word-Dokumenten und erfordern spezielle Software zum Bearbeiten oder Aktualisieren.

Curtis Chau
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Iron-Support-Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an