Przejdź do treści stopki
PORóWNANIA PRODUKTóW

Porównanie IronPDF i Textcontrol

IronPDF specjalizuje się w generowaniu HTML do PDF z silnikiem renderowania Chrome V8 dla aplikacji .NET, podczas gdy GrapeCity PDF skupia się na funkcjach przeglądania i adnotacji PDF, co czyni IronPDF lepszym wyborem dla programistów potrzebujących pełnych możliwości tworzenia PDF z wsparciem nowoczesnych treści webowych.

PDF to skrót od Portable Document Format. Jest to typ pliku, który umożliwia standardowe przeglądanie dokumentów na wielu różnych urządzeniach. Pliki PDF są często wykorzystywane do udostępniania ważnych dokumentów, takich jak CV potencjalnym pracodawcom lub faktury klientom.

Pomimo swojej popularności pliki PDF mają pewne ograniczenia. Na przykład nie można udostępniać plików PDF za pośrednictwem poczty elektronicznej, jeśli odbiorcy nie dysponują czytnikiem plików PDF. Pliki PDF mogą nie wyświetlać się wyraźnie na urządzeniach mobilnych, tak jak dokumenty WORD. Ponadto, w przeciwieństwie do dokumentów WORD, pliki PDF wymagają oprogramowania do edycji w celu modyfikacji lub aktualizacji treści. Jednak pliki PDF zachowują spójny wygląd na wszystkich urządzeniach — zarówno na komputerach PC, jak i Mac. Ta niezawodność sprawia, że pliki PDF są standardowym formatem, którego nie ma w innych typach dokumentów, takich jak JPEG czy GIF.

W tym artykułe omówimy dwie biblioteki .NET do obsługi plików PDF:

  • IronPDF
  • GrapeCity PDF

Czym jest IronPDF i jak porównuje się do GrapeCity?

IronPDF to biblioteka .NET zapewniająca funkcje tworzenia, odczytu i manipulacji dokumentami PDF przy minimalnym nakładzie kodu. W tym artykułe pokazano, jak tworzyć pliki PDF za pomocą IronPDF. Wymagana jest podstawowa znajomość Visual Studio lub języka C# oraz praktyczna znajomość HTML.

Do pisania, kompilowania i uruchamiania aplikacji potrzebne jest Visual Studio, do logiki i kodu — C#, a do formatowania plików PDF, w tym tytułów, nagłówków, obrazów i akapitów — HTML. IronPDF w pełni obsługuje .NET Core, .NET 5, Framework i Standard. W przypadku aplikacji ASP.NET IronPDF zapewnia płynną integrację w celu konwersji stron internetowych do formatu PDF.

Możesz tworzyć pliki PDF w języku C# przy użyciu minimalnej ilości kodu, posiadając podstawową wiedzę z zakresu C# i HTML. Więcej informacji można znaleźć na oficjalnej stronie poświęconej funkcjom IronPDF. W zakresie programowego tworzenia plików PDF IronPDF oferuje szerokie możliwości wykraczające poza podstawową konwersję HTML.

Jak zainstalować IronPDF w moim projekcie .NET?

Opracowanie rozwiązań wymaga zainstalowania pakietu IronPDF NuGet. Kliknij "Projekt" na pasku menu. Wybierz opcję "Zarządzaj pakietami NuGet" z menu rozwijanego. Szczegółowe instrukcje znajdują się w przeglądzie instalacji. W tym oknie wyświetli się:

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

Interfejs Menedżera Pakietów NuGet wyświetlający pusty wynik wyszukiwania przy przeszukiwaniu IronPDF, wskazujący, że pakiet może być niedostępny lub mogą istnieć problemy z łącznością

Wybierz "Przeglądaj", aby wyświetlić to okno:

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.

Menedżer pakietów NuGet zapewnia łatwy dostęp do niezbędnych bibliotek .NET, przy czym Entity Framework Core i Newtonsoft.Json należą do najpopularniejszych pakietów odpowiednio do operacji na bazach danych i obsługi JSON.

Wpisz "IronPDF" w polu wyszukiwania i naciśnij "Enter". Dla zaawansowanych opcji instalacji, włączając specyficzne konfiguracje dla platform, sprawdź dokumentację. Powinieneś zobaczyć:

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

Interfejs menedżera pakietów NuGet wyświetla różne pakiety IronPDF dostępne do instalacji, wraz z liczbą pobrań i numerami wersji widocznymi dla każdego pakietu.

Wybierz IronPDF:

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

Interfejs menedżera pakietów NuGet wyświetla IronPDF (wersja 2021.3.1) jako wybrany pakiet do instalacji, a dla porównania podaje alternatywne biblioteki PDF, w tym PDFCore i różne zasoby renderowania IronPDF.

Kliknij "Zainstaluj". Po pomyślnej instalacji zobaczysz:

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

Proces instalacji IronPDF w Visual Studio, pokazujący menedżera pakietów NuGet instalującego IronPDF w wersji 2021.3.1 wraz z jego zależnościami

Naciśnij "OK", aby zakończyć instalację. IronPDF obsługuje platformy Windows, w tym systemy Windows 10, 11 oraz wersje serwerowe. Biblioteka obsługuje również systemy Linux i macOS, umożliwiając tworzenie oprogramowania na wiele platform.

Jak tworzyć pliki PDF za pomocą IronPDF?

Dodaj przestrzeń nazw IronPDF na górze pliku. Dla programistów VB.NET, podobna funkcjonalność jest dostępna:

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

Potrzebna jest ścieżka do pliku, w którym zostanie zapisany utworzony plik PDF. Użyj SaveFileDialog, aby zachęcić użytkowników do wprowadzenia nazwy pliku i ścieżki. W zaawansowanych scenariuszach eksportuj pliki PDF do strumieni pamięci bez zapisywania na dysku:

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 otwiera okno dialogowe wyboru folderu i nazwy pliku. Domyślnym katalogiem początkowym jest dysk D, ale można go zmienić. DefaultExtension jest ustawione na PDF. Aby zapoznać się z pełnymi opcjami konwersji, przejrzyj samouczek dotyczący konwersji HTML do PDF.

Warunek "if" zawiera kod tworzący plik PDF. Wystarczą tylko dwie linijki kodu, aby wygenerować pliki PDF. PdfText jest nazwą pola Rich Text zawierającego treść PDF. Nazwa pliku to wybrana ścieżka pliku z SaveFileDialog. W przypadku aplikacji internetowych IronPDF obsługuje konwersję adresów URL do formatu PDF oraz konwersję plików ASPX do formatu PDF.

Jak czytać pliki PDF za pomocą IronPDF?

Odczytanie plików PDF wymaga tylko dwóch wierszy kodu dzięki IronPDF. Aby uzyskać informacje na temat zaawansowanego wyodrębniania, zapoznaj się z przewodnikiem dotyczącym wyodrębniania tekstu i obrazów.

Dodaj następujące importy:

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

Wpisz ten kod wewnątrz swojej funkcji. IronPDF zapewnia funkcje analizowania plików PDF oraz dostęp do DOM plików PDF:

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

Pozwala to na wyodrębnienie wszystkich informacji z dokumentów do przeglądarek. Komponenty raportujące wykorzystują te dane jako źródła. IronPDF obsługuje odczytywanie plików PDF ze strumieni pamięci oraz konwersję plików PDF do formatu HTML w celu wyświetlania w sieci.

Jakie funkcje oferuje GrapeCity PDF?

GrapeCity Documents zapewnia zarządzanie dokumentami międzyplatformowymi dla powszechnych formatów. Biblioteka .NET Standard 2.0 odczytuje, generuje, modyfikuje i zapisuje pliki PDF bez programu Adobe Acrobat. Oferuje obsługę czcionek, obrazów, grafiki, BARCODE-ów, komentarzy, konturów, stempli i znaków wodnych.

Jakie funkcje edycji plików PDF są dostępne?

GrapeCityPDF tworzy PDF dla podstawowych lub złożonych potrzeb biznesowych w aplikacjach .NET Standard. Możesz ładować, zmieniać i zapisywać PDF z dowolnego źródła. IronPDF oferuje pełną edycję plików PDF, w tym scałanie/dzielenie plików, dodawanie/usuwanie stron oraz obracanie stron.

Czy mogę konwertować pliki PDF na obrazy?

GrapeCityPDF zapisuje PDF jako obrazy bez utraty jakości, używając minimalnej ilości kodu. IronPDF oferuje funkcję rasteryzacji plików PDF do obrazów, obsługującą formaty PNG, JPEG i TIFF.

Czy GrapeCity zawiera komponent przeglądarki PDF?

GrapeCity Documents PDF Viewer to lekka przeglądarka po stronie klienta wspierająca standardowe funkcje PDF. Dla programistów .NET MAUI IronPDF oferuje przeglądanie plików PDF w aplikacjach MAUI wraz z funkcjami nawigacji i wyszukiwania.

Jakie rodzaje funkcji są obsługiwane?

GrapeCityPDF tworzy złożone PDF z tekstem, grafiką, zdjęciami, adnotacjami i konturami. IronPDF rozszerza te możliwości o podpisy cyfrowe, tworzenie i wypełnianie formularzy, znakowanie wodne oraz zarządzanie metadanymi.

Jak zainstalować GrapeCity PDF?

Istnieją dwie metody instalacji. W przypadku wdrażania w kontenerach IronPDF oferuje obsługę Docker oraz zdalne sterowanie kontenerami, co zapewnia elastyczność generowania:

  1. Pobierz spakowane pliki źródłowe w formacie ZIP.
  2. Wyodrębnij pliki do katalogu.
  3. Przejdź do tego katalogu.
  4. Wykonaj run.cmd aby zbudować próbki, uruchomić usługę SupportApi i otworzyć http://localhost:3003.
  5. Zobacz readme.MD za szczegóły.

Jak zainstalować wersję WinForms?

Postępuj zgodnie z tymi krokami, aby zainstalować wersję WinForms:

  • Download C1ControlPanel from GrapeCity's ComponentOne.
  • Otwórz ControlPanel z ComponentOneC1ControlPanel.exe (zamknij Visual Studio).
  • Zaloguj się przy użyciu zarejestrowanego adresu e-mail i hasła.
  • Dla nowych użytkowników:
    • Zarejestruj się i załóż konto.
    • Zweryfikuj adres e-mail.
    • Aktywuj za pomocą linku weryfikacyjnego.
    • Jeśli wolisz, możesz kontynuować jako anonimowy użytkownik.
  • Wybierz Zainstaluj na kafelku wydania WinForms. Zainstaluj wszystkie wydania przez zaznaczenie Wszystkie Wydania.
`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`

  • Kliknij Instaluj, aby wyświetlić Umowę licencyjną. Zaakceptuj po przejrzeniu.
  • Zaakceptuj umowę licencyjną, aby zobaczyć stronę Ustawienia. Zweryfikuj ścieżkę katalogu i rozpocznij instalację.
`ComponentOne` installation settings screen showing installation directory, samples directory, and options to join customer experience program and send system information

`ComponentOne` ekran konfiguracji instalacji z opcjami prywatności i zbierania danych

  • Instalator wyświetla postęp podczas instalacji kontrolki. Nie można anulować podczas tego procesu.
  • Kiedy pojawi się ekran z sukcesem instalacji. Pokazuje obecnie zainstalowaną wersję.
`WinForms` Edition installation dialog showing download progress and install button for 65+ UI controls

Interfejs instalatora wydania `WinForms` wyświetla prosty pasek postępu pobierania i opcję instalacji dla zestawu ponad 65 inteligentnych i efektywnych kontrol UI zaprojektowanych do szybkiego rozwoju form Windows.

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

Interfejs instalacji `ComponentOne` wyświetla komunikat o pomyślnej instalacji dla wersji 20183.1.338, zawierający zakładki nawigacyjne dla produktów, działań, licencji i wsparcia

Jak tworzę PDF z GrapeCity?

Poniższy kod demonstruje podstawowe tworzenie PDF z użyciem GrapeCity. Dla zaawansowanych funkcji takich jak HTML-to-PDF z JavaScript, responsywne CSS, czy niestandardowe nagłówki/stopki, IronPDF oferuje kompletne rozwiązania:

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 oferuje ograniczone funkcje w porównaniu do IronPDF. IronPDF wspiera zgodność z PDF/A, dostępność w PDF/UA, niestandardowe rozmiary papieru, i zaawansowane opcje renderowania.

Jakie są modele licencji i ceny IronPDF?

30-dniowa gwarancja zwrotu pieniędzy: Po zakupie licencji, otrzymasz 30-dniową gwarancję zwrotu pieniędzy. Jeśli licencja nie jest odpowiednia do twoich potrzeb, IronPDF zwróci ci pieniądze w ciągu 30 dni.

Łatwe zintegrowanie: Integracja IronPDF obok działającego projektu i twojego środowiska jest płynnym procesem zakończonym przy użyciu jednej linii kodu. Można to osiągnąć podczas integracji przy użyciu metody NuGet Package lub pobrane bezpośrednio online i zintegrowane w twoim środowisku.

Licencjonowanie wieczyste: Każda licencja jest zakupiona tylko raz bez wymagań odnowienia.

Bezplatne wsparcie i aktualizacje produktu: Każda licencja będzie zawierać rundę wsparcia "od podstaw" bezpośrednio od zespołu stojącego za produktem oraz rok darmowych aktualizacji produktu. Jest możliwe zakupienie rozszerzeń w dowolnym momencie. Rozszerzenia mogą być obejrzane przed zakupem.

Natywne licencje: Jak tylko płatność się zakończy, zarejestrowane klucze licencyjne są wysyłane.

Wszystkie licencje są wieczyste do testowania, rozwoju i produkcji.

Jak IronPDF wspiera nowoczesne frameworki webowe, takie jak Bootstrap?

Nowoczesne tworzenie PDF korzysta z wizualnych reprezentacji procesów. Ten przykład Bootstrap 5 demonstruje zdolność IronPDF do renderowania harmonogramów przepływu pracy za pomocą kart, odznak i wskaźników kroków. Dla pełnego wsparcia frameworka, zobacz przewodnik rozwiązywania problemów Bootstrap & Flexbox:

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

Wyjście: Profesjonalny harmonogram przepływu pracy PDF z kartami Bootstrap 5, odznakami, paskami postępu i niestandardowym stylem harmonogramu. IronPDF dokładnie renderuje wszystkie pozycjonowania, układy flexbox i klasy użytkowe, demonstrując kompleksowe wsparcie CSS3 dla złożonych wizualnych projektów.

Aby uzyskać szczegółową kompatybilność z Bootstrapem, zobacz przewodnik Bootstrap & Flexbox CSS. IronPDF wspiera czcionki webowe i ikony dla bogatej typografii.

Jakie są ceny pakietu Lite?

  • 1 Deweloper
  • 1 Lokalizacja
  • 1 Projekt
  • Licencja Wieczysta

Ten pakiet pozwala jednemu deweloperowi na użycie Iron Software w jednej lokalizacji dla jednej aplikacji. Licencje są niewytransferowalne poza organizacje lub relacje agencja/klient. Wyłącza redystrybucję OEM i użycie w SaaS bez dodatkowego pokrycia.

Ceny: zaczynają się od $999 rocznie.

Co zawiera licencja Professional?

  • 10 Deweloperów
  • 10 Lokalizacji
  • 10 Projektów
  • Licencja Wieczysta

Ta licencja pozwala dziesięciu deweloperom na użycie Iron Software w do dziesięciu lokalizacjach. Możesz jej używać w nieograniczonej liczbie stron www, aplikacjach intranetowych lub oprogramowaniu desktopowym. Licencje są niewytransferowalne poza organizacjami. Wyłącza redystrybucję OEM i użycie w SaaS bez dodatkowego pokrycia. Integruje się z do 10 projektami.

Ceny: Zaczynają się od $1,499 rocznie.

Jakie są korzyści z Unlimited License?

  • Nieograniczona liczba deweloperów
  • Nieograniczona liczba lokalizacji
  • Nieograniczona liczba projektów
  • Licencja Wieczysta

Pozwala na to, by nieograniczona liczba deweloperów w jednej organizacji mogła korzystać z Iron Software w nieograniczonej liczbie lokalizacji. Użyj w nieograniczonej liczbie aplikacji. Licencje są niewytransferowalne poza organizacjami. Wyłącza redystrybucję OEM i użycie w SaaS bez dodatkowego pokrycia.

Ceny: Zaczynają się od $2,999 rocznie.

Redystrybucja bez opłat licencyjnych: Pozwala to na dystrybucję Iron Software jako część kilku różnie pakowanych produktów komercyjnych (bez konieczności płacenia tantiem) na podstawie liczby projektów objętych podstawową licencją. To pozwoli na wdrożenie Iron Software w ramach usług SaaS, co oparte jest na liczbie projektów objętych podstawową licencją.

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

IronPDF oferuje wiele poziomów licencji, które pasują do indywidualnych deweloperów, zespołów oraz wdrożeń w przedsiębiorstwach. Odwiedź stronę licencjonowania IronPDF w celu uzyskania aktualnych cen.

Jakie są modele licencji i ceny GrapeCity PDF?

Co zawiera licencja Documents for PDF?

  • Obejmuje 1 licencję dewelopera
  • 1 lokalizacja dystrybucyjna

Obejmuje jedną licencję dewelopera i jedną lokalizację dystrybucyjną bez wsparcia i konserwacji.

Aby uzyskać aktualne ceny, odwiedź bezpośrednio stronę internetową MESCIUS (dawniej GrapeCity), ponieważ ceny opierają się na subskrypcji i mogą ulec zmianie.

Czym jest Documents for PDF Unlimited?

  • Obejmuje 1 licencję dewelopera
  • Nieograniczone lokalizacje dystrybucyjne

Obejmuje jedną licencję dewelopera z nieograniczoną liczbą lokalizacji dystrybucyjnych. Brak wsparcia i konserwacji. GrapeCity nie wspiera SaaS i OEM.

Aby uzyskać aktualne ceny, odwiedź bezpośrednio stronę internetową MESCIUS (dawniej GrapeCity), ponieważ ceny opierają się na subskrypcji i mogą ulec zmianie.

Co oferuje Documents for PDF Team Unlimited?

  • Obejmuje 5 licencji dewelopera
  • Nieograniczone lokalizacje dystrybucyjne

Obejmuje pięć licencji dewelopera z nieograniczoną liczbą lokalizacji dystrybucyjnych. Brak wsparcia i konserwacji. GrapeCity nie wspiera SaaS i OEM.

Aby uzyskać aktualne ceny, odwiedź bezpośrednio stronę internetową MESCIUS (dawniej GrapeCity), ponieważ ceny opierają się na subskrypcji i mogą ulec zmianie.

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

Struktura cenowa `GrapeCity` Documents for PDF oferuje trzy poziomy, aby dostosować się do różnych wielkości zespołów deweloperskich i potrzeb dystrybucyjnych.

Pakiet IronPDF Lite One-Developer obejmuje roczne wsparcie dla $999. Ceny dla Documents for PDF opracowane przez MESCIUS (dawniej GrapeCity) są oparte na subskrypcji - odwiedź oficjalną stronę MESCIUS w celu uzyskania aktualnych stawek. Pakiet IronPDF Professional obejmuje 10 deweloperów z rocznym wsparciem dla $1,499. Aby uzyskać więcej informacji na temat opcji licencjonowania IronPDF, odwiedź oficjalną stronę licencjonowania.

Pakiety IronPDF Lite i Professional obejmują usługi SaaS, OEM oraz opcje wsparcia na 5 lat. Warunki licencjonowania MESCIUS (dawniej GrapeCity) oraz zakres wsparcia SaaS/OEM różnią się — sprawdź szczegóły na oficjalnej stronie MESCIUS. Dowiedz się więcej o rozszerzeniach licencji i opcja aktualizacji dla długoterminowego wsparcia.

Którą bibliotekę PDF wybrać do mojego projektu .NET?

Documents for PDF GrapeCity pozwala na eksport/import, AcroForms tworzenie i wykonanie PDF w aplikacjach desktopowych. Jednak dla pełnej manipulacji PDF, w tym tworzenia formularzy, podpisów cyfrowych oraz wsparcia dla adnotacji, IronPDF oferuje zaawansowane funkcje.

IronPDF zapewnia większą dokładność. Konkurenci mogą napotkać problemy, takie jak nieudana konwersja obrazów lub nieznane znaki. IronPDF dostarcza precyzyjne wyniki. Silnik renderujący Chrome zapewnia renderowanie idealne w pikselach, weryfikowane za pomocą Pixel-perfect HTML to PDF guide. Dla optymalizacji zobacz przewodnik pomocy wydajnościowej IronPDF.

IronPDF oferuje konkurencyjne licencje i wsparcie bez bieżących kosztów. Ceny IronPDF zaczynają się od $999 z pełnymi pakietami funkcji. MESCIUS (dawniej GrapeCity) stosuje cenę opartą na subskrypcji — skonsultuj się z oficjalną stroną MESCIUS w celu uzyskania aktualnych stawek. IronPDF obsługuje wiele platform w ramach jednej ceny. W przypadku wdrożeń Enterprise IronPDF zapewnia funkcje asynchroniczne i wielowątkowe, umożliwiające generowanie dokumentów z wysoką wydajnością.

Możesz skorzystać z bezpłatnej wersji próbnej, aby zapoznać się ze wszystkimi funkcjami. Zakup kompletnego pakietu Iron Suite zapewnia pięć produktów w cenie dwóch. Szczegóły dotyczące licencjonowania IronPDF znajdziesz na stronie produktu Iron Suite firmy Iron Software dla pełnej informacji o pakietach.

Zwróć uwagęGrapeCity Documents for PDF to zarejestrowany znak towarowy swojego właściciela. Ta strona nie jest powiązana z, sponsorowana ani wspierana przez GrapeCity Documents for PDF. Wszystkie nazwy produktów, logo i marki są własnością ich odpowiednich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.

Często Zadawane Pytania

Jak mogę przekonwertować HTML na PDF w .NET?

Możesz użyć metody RenderHtmlAsPdf biblioteki IronPDF do konwersji ciągów HTML na pliki PDF. Dodatkowo możesz konwertować pliki HTML na pliki PDF za pomocą metody RenderHtmlFileAsPdf.

Jakie są kroki instalacji biblioteki PDF przy użyciu NuGet?

Aby zainstalować IronPDF za pomocą NuGet, otwórz Visual Studio, przejdź do „Zarządzaj pakietami NuGet”, wyszukaj „IronPdf” i kliknij „Zainstaluj”, aby dodać go do swojego projektu.

Jakie są alternatywy dla programu GrapeCity PDF Viewer dla platformy .NET?

IronPDF jest odpowiednią alternatywą dla przeglądarki PDF firmy GrapeCity, zapewniającą przyjazne dla użytkownika środowisko pracy oraz szerokie wsparcie dla platform .NET Core, .NET 5, Framework i Standard.

Jak tworzyć i odczytywać pliki PDF za pomocą biblioteki .NET?

Korzystając z IronPDF, można tworzyć pliki PDF poprzez dołączenie przestrzeni nazw IronPdf i użycie klasy HtmlToPdf do renderowania HTML jako PDF. Aby odczytywać pliki PDF, można użyć klasy PdfDocument w celu uzyskania dostępu do treści i manipulowania nią.

Jakie opcje licencyjne są dostępne dla biblioteki PDF?

IronPDF oferuje szereg opcji licencyjnych, w tym pakiet Lite dla pojedynczych programistów, Professional License dla maksymalnie 10 programistów oraz Unlimited License dla zespołów, wszystkie z opcjami licencji wieczystej i wsparcia technicznego.

Dlaczego warto wybrać IronPDF zamiast innych rozwiązań do obsługi plików PDF?

IronPDF jest polecany ze względu na swoją dokładność, wszechstronne funkcje, konkurencyjne licencje i szerokie możliwości wsparcia. Oferuje obsługę wielu platform w konkurencyjnej cenie.

Czy mogę wypróbować bibliotekę PDF przed zakupem?

Tak, IronPDF oferuje bezpłatną wersję próbną, która pozwala zapoznać się ze wszystkimi dostępnymi funkcjami przed podjęciem decyzji o zakupie. Ponadto pakiet Iron Suite zapewnia dostęp do wszystkich produktów Iron Software po obniżonej cenie.

Jakie są wady korzystania z plików PDF?

Pliki PDF mogą być trudne do udostępniania za pośrednictwem poczty elektronicznej ze względu na ich rozmiar, mogą nie wyświetlać się wyraźnie na urządzeniach mobilnych w porównaniu z dokumentami WORDa oraz wymagają specjalnego oprogramowania do edycji lub aktualizacji.

Curtis Chau
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Zespół wsparcia Iron

Jesteśmy online 24 godziny, 5 dni w tygodniu.
Czat
E-mail
Zadzwoń do mnie