Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Produktvergleiche
  4. C# PDF-Bibliotheksvergleich
PRODUKTVERGLEICHE

C# PDF-Bibliotheksvergleich: IronPDF vs iText 7, PDFSharp, Aspose, Syncfusion, QuestPDF & mehr

Curtis Chau
Curtis Chau
Aktualisiert:

Für Entwicklungsleiter, die C# PDF-Bibliotheken evaluieren, bietet IronPDF die beste Rendite, da es die Entwicklungszeit verkürzt und einen vollständigen Funktionsumfang bietet. Im Gegensatz dazu eignen sich Open-Source-Optionen wie PDFSharp für grundlegende Programmieraufgaben bei geringeren Anfangskosten.

Die Arbeit mit PDF-Dokumenten in modernen .NET Anwendungen gewinnt zunehmend an Bedeutung. Egal ob Sie Rechnungen erstellen, Berichte konvertieren oder Formulare in Webanwendungen integrieren, Sie benötigen zuverlässige C# PDF-Bibliotheken. Welche der zahlreichen verfügbaren PDF-Bibliotheken ist die beste für Ihr Projekt?

Dieser Artikel untersucht IronPDF im Vergleich zu beliebten Alternativen wie iText , PDFSharp, Aspose , Syncfusion , QuestPDF und anderen. Sie erfahren, wie die einzelnen .NET PDF-Bibliotheken die PDF-Generierung , die HTML-zu-PDF-Konvertierung , die Bearbeitung und andere wichtige Funktionen handhaben. Der Vergleich umfasst Lizenzierung , Leistung und Benutzerfreundlichkeit, um Ihnen bei der richtigen Entscheidung zu helfen.

Warum benötigen Sie eine C#-PDF-Bibliothek?

Bevor Sie sich mit einzelnen Produkten befassen, überlegen Sie, warum Sie C#-Bibliotheken für PDF-Dateien benötigen:

Ihre PDF-Bibliothek sollte einfach zu bedienen sein, minimalen Code erfordern und eine hohe Darstellungsqualität bieten. Für die Cloud-Bereitstellung empfehlen wir Ihnen die Leitfäden zur Azure-Bereitstellung und zur AWS Lambda-Integration .

Welche PDF-Bibliotheksfunktionen sind für Ihr Team am wichtigsten?

Bibliothek HTML zu PDF JS-Unterstützung PDF bearbeiten Lizenz Bester Anwendungsfall
IronPDF Ja Vollständig Yes Kommerziell Web-Apps mit dynamischen Inhalten
iText 7 Ja Begrenzt Yes Kommerziell Enterprise und statisches HTML
PDFSharp / MigraDoc Nein N/V Partial Open-Source Programmatische PDF-Erstellung und benutzerdefinierte Layouts
Aspose.PDF Ja Teilweise Yes Kommerziell Unternehmensautomatisierung und Mehrformatkonvertierung
Syncfusion PDF Ja Teilweise Yes Kommerziell Berichterstellung und Dashboards
QuestPDF Nein N/V Yes Open-Source Strukturierte programmatische PDFs
wkhtmltopdf (DinkToPdf) Ja Begrenzt Nein Open-Source Konvertierung von statischem HTML in PDF

Diese Tabelle bietet einen schnellen Überblick über die Kernstärken jeder Bibliothek und hilft Ihnen, das richtige Werkzeug anhand der HTML/JS-Unterstützung, der Bearbeitungsmöglichkeiten und der Lizenzierung zu identifizieren. In den folgenden Abschnitten wird untersucht, wie die einzelnen Bibliotheken grundlegende Aufgaben wie die Konvertierung von HTML in PDF oder die allgemeine PDF-Erstellung handhaben.

Was ist IronPDF und wann sollte man es verwenden?

IronPDF ist eine moderne, kommerzielle .NET PDF-Bibliothek, die die PDF-Bearbeitung einfach und effektiv gestaltet. Im Gegensatz zu Bibliotheken, die manuelles Zeichnen oder Low-Level-APIs erfordern, konzentriert sich IronPDF auf praxisnahe Anwendungsfälle: HTML-zu-PDF -Konvertierung, PDF-Bearbeitung und Berichtserstellung mit minimalem Codeaufwand. Die Implementierung übernimmt die Komplexität für Sie, insbesondere bei Webanwendungen, deren Inhalte in HTML vorliegen. IronPDF läuft unter Windows, .NET Framework, .NET Core und containerisierten Plattformen wie Docker und ist daher vielseitig für lokale und Cloud-Bereitstellungen geeignet.

Warum sollte sich Ihr Team für IronPDF entscheiden?

Wie geht IronPDF mit komplexen Webinhalten um?

Um zu demonstrieren, wie IronPDF mit HTML-Inhalten mit komplexem CSS oder JavaScript umgeht, betrachten Sie das folgende Beispiel zur URL-Konvertierung :

using IronPdf;

class Program
{
    static void Main()
    {
        // Initialize the Chrome PDF renderer
        var renderer = new ChromePdfRenderer();

        // Configure rendering options for optimal output
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.WaitFor.JavaScript(3000); // Wait 3 seconds for JS execution

        // Set page size and margins
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 10; // millimeters
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;

        // Convert URL to PDF
        var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_170___");

        // Save the PDF document
        pdf.SaveAs("output.pdf");

        // Optional: Add metadata
        pdf.MetaData.Title = "Wikipedia Main Page";
        pdf.MetaData.Author = "IronPDF Example";
        pdf.MetaData.Subject = "URL to PDF Conversion";
    }
}
using IronPdf;

class Program
{
    static void Main()
    {
        // Initialize the Chrome PDF renderer
        var renderer = new ChromePdfRenderer();

        // Configure rendering options for optimal output
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.WaitFor.JavaScript(3000); // Wait 3 seconds for JS execution

        // Set page size and margins
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 10; // millimeters
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;

        // Convert URL to PDF
        var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_170___");

        // Save the PDF document
        pdf.SaveAs("output.pdf");

        // Optional: Add metadata
        pdf.MetaData.Title = "Wikipedia Main Page";
        pdf.MetaData.Author = "IronPDF Example";
        pdf.MetaData.Subject = "URL to PDF Conversion";
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        ' Initialize the Chrome PDF renderer
        Dim renderer = New ChromePdfRenderer()

        ' Configure rendering options for optimal output
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
        renderer.RenderingOptions.EnableJavaScript = True
        renderer.RenderingOptions.WaitFor.JavaScript(3000) ' Wait 3 seconds for JS execution

        ' Set page size and margins
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 10 ' millimeters
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10

        ' Convert URL to PDF
        Dim pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_170___")

        ' Save the PDF document
        pdf.SaveAs("output.pdf")

        ' Optional: Add metadata
        pdf.MetaData.Title = "Wikipedia Main Page"
        pdf.MetaData.Author = "IronPDF Example"
        pdf.MetaData.Subject = "URL to PDF Conversion"
    End Sub
End Class
$vbLabelText   $csharpLabel

Welche Ergebnisse können Sie erwarten?

Screenshot der Wikipedia-Startseite mit Hauptlayout, Artikel über die Fotografin Felice Beato, Nachrichtenbereich mit der Verurteilung von Jair Bolsonaro und dem Abschnitt

Mit minimalem Codeaufwand erzeugt IronPDF hochauflösende PDFs, die komplexe CSS-Layouts und dynamische JavaScript Inhalte wiedergeben. Die Chrome-Rendering-Engine der Bibliothek gewährleistet eine pixelgenaue Ausgabe, die mit modernen Browsern kompatibel ist. Ihre Anwendung kann diese Funktion sofort für die Verarbeitung von Cookies , HTTP-Headern oder die Authentifizierung nutzen.

Fazit: IronPDF ist die beste Wahl für die benutzerfreundliche und leistungsstarke PDF-Erstellung mit exzellentem HTML/CSS/JS-Rendering und Professional Support. Sehen Sie sich die Demos an, um es in Aktion zu erleben.

Wie gehen PDF-Bibliotheken mit Bootstrap und modernen CSS-Frameworks um?

Bei der Auswahl einer C# PDF-Bibliothek für Anwendungen, die Bootstrap und moderne CSS-Frameworks verwenden, entscheidet die Framework-Kompatibilität darüber, ob Ihre Designs korrekt konvertiert werden oder angepasst werden müssen. Dieser Ansatz bietet klare Vorteile für Teams, die responsive Designmuster verwenden.

Warum ist Chromium-basiertes Rendering für Bootstrap wichtig?

Die Chromium-Engine von IronPDF bietet vollständige Unterstützung für:

  • Bootstrap 5: Vollständige Flexbox-Layouts, CSS Grid, Utility-Klassen, alle Komponenten
  • Bootstrap 4: Vollständiges Kartensystem, Navigation, Flexbox-Funktionen, responsives Design
  • Tailwind CSS: Alle Utility-Klassen mit browsergenauer Darstellung
  • Fundament: Vollständiges Grid-System und Komponentenunterstützung
  • Modernes CSS3: Flexbox, CSS Grid, benutzerdefinierte Eigenschaften, Animationen, Übergänge

Praxistest: IronPDF rendert die Bootstrap-Homepage und offizielle Beispiele pixelgenau. Die Bibliothek kümmert sich um die Komplexität für Sie, einschließlich Google Fonts , SVG-Grafiken und benutzerdefinierter Schriftarten .

Welche Einschränkungen von Bootstrap sind zu erwarten?

iText 7: Eingeschränkte Flexbox-Unterstützung (hinzugefügt in Version 7.1.15), kein CSS Grid, Einschränkungen durch Bootstrap 3, erfordert Workarounds für moderne Komponenten.

PDFSharp & MigraDoc: Keine native HTML-Darstellung – nur manuelle PDF-Erstellung, keine Bootstrap-Unterstützung.

Aspose.PDF: Eigene Engine mit ca. 90% CSS3-Unterstützung, teilweisem Flexbox, erfordert umfangreiche Tests für Bootstrap-Komponenten.

Syncfusion PDF: WebKit-basierte Engine ohne Flexbox/CSS Grid, maximal Bootstrap 3, Sicherheitslücken (zuletzt aktualisiert 2016).

QuestPDF: Flüssige API für manuelles Layout – kein HTML/CSS-Rendering, keine Bootstrap-Unterstützung.

Auswirkungen auf die Entwicklung: Bibliotheken ohne Chromium-Unterstützung erfordern parallele, "PDF-sichere" Layouts, was die Entwicklungszeit erheblich verlängert und die Designkonsistenz verringert.

Was ist iText 7 und wann sollte man es verwenden?

iText 7 ist eine zuverlässige, unternehmensgerechte C#-PDF-Bibliothek zum Generieren, Bearbeiten und Sichern von PDFs. Die Implementierung unterstützt PDF/A , digitale Signaturen , Schwärzung und Compliance-intensive Workflows für Finanz-, Rechts- und Enterprise . Während iText 7 die Konvertierung von HTML in PDF übernimmt, führt es JavaScript nicht nativ aus, weshalb eine Vorverarbeitung für dynamische Inhalte erforderlich ist. Version 7.1.15 bietet eingeschränkte Flexbox-Unterstützung, viele CSS3-Funktionen werden jedoch weiterhin nicht unterstützt. Sehen Sie sich unseren Vergleich zwischen iText und IronPDF an.

Was macht iText 7 für Enterprise geeignet?

Wie konvertiert iText 7 URLs in PDF?

using iText.Html2pdf;
using System.Net.Http;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var url = "___PROTECTED_URL_171___";

        // Create HTTP client with browser-like settings
        using var client = new HttpClient();

        // Add user agent to avoid 403 Forbidden responses
        client.DefaultRequestHeaders.Add("User-Agent", 
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " +
            "(KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36");

        // Add timeout for reliability
        client.Timeout = TimeSpan.FromSeconds(30);

        // Fetch HTML content
        string htmlContent = await client.GetStringAsync(url);

        // Configure conversion properties
        var converterProperties = new ConverterProperties();
        converterProperties.SetBaseUri(url); // Important for resolving relative URLs

        // Create PDF from HTML
        using var fileStream = new FileStream("itext7-output.pdf", FileMode.Create);
        HtmlConverter.ConvertToPdf(htmlContent, fileStream, converterProperties);

        Console.WriteLine("PDF created successfully!");
    }
}
using iText.Html2pdf;
using System.Net.Http;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var url = "___PROTECTED_URL_171___";

        // Create HTTP client with browser-like settings
        using var client = new HttpClient();

        // Add user agent to avoid 403 Forbidden responses
        client.DefaultRequestHeaders.Add("User-Agent", 
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " +
            "(KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36");

        // Add timeout for reliability
        client.Timeout = TimeSpan.FromSeconds(30);

        // Fetch HTML content
        string htmlContent = await client.GetStringAsync(url);

        // Configure conversion properties
        var converterProperties = new ConverterProperties();
        converterProperties.SetBaseUri(url); // Important for resolving relative URLs

        // Create PDF from HTML
        using var fileStream = new FileStream("itext7-output.pdf", FileMode.Create);
        HtmlConverter.ConvertToPdf(htmlContent, fileStream, converterProperties);

        Console.WriteLine("PDF created successfully!");
    }
}
Imports iText.Html2pdf
Imports System.Net.Http
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim url As String = "___PROTECTED_URL_171___"

        ' Create HTTP client with browser-like settings
        Using client As New HttpClient()

            ' Add user agent to avoid 403 Forbidden responses
            client.DefaultRequestHeaders.Add("User-Agent", 
                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " &
                "(KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36")

            ' Add timeout for reliability
            client.Timeout = TimeSpan.FromSeconds(30)

            ' Fetch HTML content
            Dim htmlContent As String = Await client.GetStringAsync(url)

            ' Configure conversion properties
            Dim converterProperties As New ConverterProperties()
            converterProperties.SetBaseUri(url) ' Important for resolving relative URLs

            ' Create PDF from HTML
            Using fileStream As New FileStream("itext7-output.pdf", FileMode.Create)
                HtmlConverter.ConvertToPdf(htmlContent, fileStream, converterProperties)
            End Using

            Console.WriteLine("PDF created successfully!")
        End Using
    End Function
End Module
$vbLabelText   $csharpLabel

Welche Einschränkungen gibt es bei der HTML-Darstellung von iText 7?

Screenshot der Wikipedia-Seitenleistennavigation mit komplexen, verschachtelten Menüs, Links und Formularelementen, die die Herausforderungen für PDF-Konvertierungstools verdeutlichen

Dieser Code ruft HTML-Inhalte ab und konvertiert sie in PDF. Das Ergebnis erhält das Seitenlayout, den Text, die Bilder und die CSS-Stile, dynamische JavaScript Inhalte werden jedoch nicht gerendert. Für Seiten mit hohem JavaScript-Anteil empfiehlt sich das JavaScript Rendering von IronPDF oder die Implementierung benutzerdefinierter Rendering-Verzögerungen .

Fazit: iText 7 überzeugt mit der Erstellung und Bearbeitung von PDFs für Enterprise , starker Unterstützung von Compliance-Vorgaben und der Konvertierung von statischem HTML in PDF. Für JavaScript oder fortgeschrittenes CSS sollten Sie IronPDF oder wkhtmltopdf in Betracht ziehen.

Was sind PDFSharp & MigraDoc und wann sollte man sie verwenden?

PDFSharp und MigraDoc sind kostenlose Open-Source-C#-PDF-Bibliotheken zur programmatischen PDF-Erstellung. PDFSharp übernimmt die Erstellung von PDFs auf niedriger Ebene, während MigraDoc Layout-APIs auf hoher Ebene für Tabellen, Absätze und mehrseitige Dokumente bereitstellt. Diese Bibliotheken bieten keine HTML-zu-PDF-Konvertierung und sind daher ideal, wenn Sie die volle Kontrolle über die Dokumentstruktur im Code benötigen. Für programmatisches Zeichnen siehe Anleitungen zum Zeichnen von Linien und Rechtecken sowie zum Zeichnen von Text und Bitmaps .

Warum PDFSharp für die einfache PDF-Erstellung wählen?

  • Kostenlos und Open Source (MIT-Lizenz).

  • Erstellen Sie programmgesteuert PDFs mit Text, Bildern und Tabellen.

  • Unterstützung für mehrseitige Layouts mit MigraDoc.

  • Leichtgewicht und einfach zu integrieren.

  • Volle Kontrolle über Zeichnung und Positionierung.

  • Funktioniert unter .NET Framework und .NET Core .

Wie erstellt man mit PDFSharp programmgesteuert PDFs?

using PdfSharp.Drawing;
using PdfSharp.Fonts;
using PdfSharp.Pdf;
using static System.Net.Mime.MediaTypeNames;

class Program
{
    static void Main()
    {
        // Configure font resolver for cross-platform compatibility
        GlobalFontSettings.UseWindowsFontsUnderWindows = true;

        // Create a new PDF document
        var document = new PdfDocument();
        document.Info.Title = "PDFSharp Example";
        document.Info.Author = "Your Team";
        document.Info.Subject = "Demonstrating PDFSharp capabilities";

        // Add a page to the document
        var page = document.AddPage();
        page.Size = PdfSharp.PageSize.A4;
        page.Orientation = PdfSharp.PageOrientation.Portrait;

        // Create graphics object for drawing
        var gfx = XGraphics.FromPdfPage(page);

        // Draw text at specific coordinates
        var font = new XFont("Verdana", 20, XFontStyleEx.Regular);
        gfx.DrawString("Hello from PDFSharp!", font, XBrushes.Black, 
            new XPoint(50, 100));

        // Add more content - a rectangle
        var pen = new XPen(XColors.Navy, 2);
        gfx.DrawRectangle(pen, XBrushes.LightBlue, 50, 150, 200, 100);

        // Add text inside rectangle
        var smallFont = new XFont("Arial", 12, XFontStyleEx.Regular);
        gfx.DrawString("Custom drawing example", smallFont, XBrushes.DarkBlue, 
            new XPoint(60, 200));

        // Save the document
        document.Save("pdfsharp-example.pdf");

        Console.WriteLine("PDF created with PDFSharp!");
    }
}
using PdfSharp.Drawing;
using PdfSharp.Fonts;
using PdfSharp.Pdf;
using static System.Net.Mime.MediaTypeNames;

class Program
{
    static void Main()
    {
        // Configure font resolver for cross-platform compatibility
        GlobalFontSettings.UseWindowsFontsUnderWindows = true;

        // Create a new PDF document
        var document = new PdfDocument();
        document.Info.Title = "PDFSharp Example";
        document.Info.Author = "Your Team";
        document.Info.Subject = "Demonstrating PDFSharp capabilities";

        // Add a page to the document
        var page = document.AddPage();
        page.Size = PdfSharp.PageSize.A4;
        page.Orientation = PdfSharp.PageOrientation.Portrait;

        // Create graphics object for drawing
        var gfx = XGraphics.FromPdfPage(page);

        // Draw text at specific coordinates
        var font = new XFont("Verdana", 20, XFontStyleEx.Regular);
        gfx.DrawString("Hello from PDFSharp!", font, XBrushes.Black, 
            new XPoint(50, 100));

        // Add more content - a rectangle
        var pen = new XPen(XColors.Navy, 2);
        gfx.DrawRectangle(pen, XBrushes.LightBlue, 50, 150, 200, 100);

        // Add text inside rectangle
        var smallFont = new XFont("Arial", 12, XFontStyleEx.Regular);
        gfx.DrawString("Custom drawing example", smallFont, XBrushes.DarkBlue, 
            new XPoint(60, 200));

        // Save the document
        document.Save("pdfsharp-example.pdf");

        Console.WriteLine("PDF created with PDFSharp!");
    }
}
Imports PdfSharp.Drawing
Imports PdfSharp.Fonts
Imports PdfSharp.Pdf
Imports System.Net.Mime.MediaTypeNames

Module Program
    Sub Main()
        ' Configure font resolver for cross-platform compatibility
        GlobalFontSettings.UseWindowsFontsUnderWindows = True

        ' Create a new PDF document
        Dim document As New PdfDocument()
        document.Info.Title = "PDFSharp Example"
        document.Info.Author = "Your Team"
        document.Info.Subject = "Demonstrating PDFSharp capabilities"

        ' Add a page to the document
        Dim page = document.AddPage()
        page.Size = PdfSharp.PageSize.A4
        page.Orientation = PdfSharp.PageOrientation.Portrait

        ' Create graphics object for drawing
        Dim gfx = XGraphics.FromPdfPage(page)

        ' Draw text at specific coordinates
        Dim font As New XFont("Verdana", 20, XFontStyleEx.Regular)
        gfx.DrawString("Hello from PDFSharp!", font, XBrushes.Black, New XPoint(50, 100))

        ' Add more content - a rectangle
        Dim pen As New XPen(XColors.Navy, 2)
        gfx.DrawRectangle(pen, XBrushes.LightBlue, 50, 150, 200, 100)

        ' Add text inside rectangle
        Dim smallFont As New XFont("Arial", 12, XFontStyleEx.Regular)
        gfx.DrawString("Custom drawing example", smallFont, XBrushes.DarkBlue, New XPoint(60, 200))

        ' Save the document
        document.Save("pdfsharp-example.pdf")

        Console.WriteLine("PDF created with PDFSharp!")
    End Sub
End Module
$vbLabelText   $csharpLabel

Wann ist PDFSharp die richtige Wahl?

PDF-Viewer, der ein einfaches Dokument mit dem Text

Dieser Code generiert PDFs programmatisch, fügt Text hinzu und kümmert sich um das Layout. Die Implementierung bietet klare Vorteile für individuell angepasste Dokumente ohne HTML-Eingabe, wie Rechnungen , Formulare oder Zertifikate . Für eine ähnliche programmatische Steuerung mit mehr Funktionen siehe Erstellen neuer PDFs .

Fazit: PDFSharp & MigraDoc eignen sich ideal für die Erstellung einfacher PDFs – sie sind kostenlos und einfach zu integrieren, bieten aber keine HTML-Konvertierung und keine erweiterten Bearbeitungsmöglichkeiten. Für HTML-Workflows sollten Sie die HTML-zu-PDF-Funktionen von IronPDF in Betracht ziehen. ## Was ist Aspose.PDF und wann sollten Sie es verwenden?

Aspose.PDF ist eine kommerzielle .NET PDF-Bibliothek, die umfassende Werkzeuge zum Erstellen, Bearbeiten, Konvertieren und Sichern von PDFs bietet. Im Gegensatz zu schlanken Bibliotheken konzentriert sich Aspose.PDF auf Enterprise und unterstützt Dateikonvertierungen, darunter Word , Excel, HTML und XML . Ihre Anwendung kann diese Funktion sofort für die Dokumentenautomatisierung , die Berichtserstellung und die erweiterte PDF-Bearbeitung in großen Anwendungen nutzen. Sehen Sie sich unseren Vergleich zwischen Aspose und IronPDF an.

Welche Enterprise Funktionen bietet Aspose.PDF?

Wie funktioniert die URL-zu-PDF-Konvertierung in Aspose.PDF?

using Aspose.Pdf;
using System;
using System.IO;
using System.Net;

class Program
{
    static void Main()
    {
        string url = "___PROTECTED_URL_172___";

        // Optional: provide credentials for protected resources
        NetworkCredential credentials = null;
        // Example for authenticated resources:
        // credentials = new NetworkCredential("username", "password");

        // Configure HTML load options
        var options = new HtmlLoadOptions(url)
        {
            // Enable external resources loading
            ExternalResourcesCredentials = credentials,

            // Set page info
            PageInfo = new PageInfo
            {
                Width = PageSize.A4.Width,
                Height = PageSize.A4.Height,
                Margin = new MarginInfo(20, 20, 20, 20) // left, bottom, right, top
            },

            // Enable JavaScript execution (limited support)
            IsEmbedFonts = true,
            IsRenderToSinglePage = false
        };

        try
        {
            // Fetch HTML content as stream and load into Document
            using (var document = new Document(GetContentFromUrlAsStream(url, credentials), options))
            {
                // Add metadata
                document.Info.Title = "Wikipedia Main Page";
                document.Info.Author = "Aspose.PDF Example";
                document.Info.Subject = "URL to PDF Conversion";
                document.Info.Keywords = "PDF, Aspose, Wikipedia";

                // Improve the PDF
                document.OptimizeResources();

                // Save PDF with specific save options
                var saveOptions = new PdfSaveOptions
                {
                    DefaultFontName = "Arial", // Fallback font
                    EmbedStandardFonts = true
                };

                document.Save("aspose-output.pdf", saveOptions);
            }

            Console.WriteLine("PDF successfully created!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }

    private static Stream GetContentFromUrlAsStream(string url, ICredentials credentials = null)
    {
        using var handler = new System.Net.Http.HttpClientHandler { Credentials = credentials };
        using var httpClient = new System.Net.Http.HttpClient(handler);

        // Set a browser-like User-Agent to avoid 403 errors
        httpClient.DefaultRequestHeaders.Add("User-Agent",
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " +
            "(KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36");

        // Set timeout
        httpClient.Timeout = TimeSpan.FromSeconds(30);

        return httpClient.GetStreamAsync(url).GetAwaiter().GetResult();
    }
}
using Aspose.Pdf;
using System;
using System.IO;
using System.Net;

class Program
{
    static void Main()
    {
        string url = "___PROTECTED_URL_172___";

        // Optional: provide credentials for protected resources
        NetworkCredential credentials = null;
        // Example for authenticated resources:
        // credentials = new NetworkCredential("username", "password");

        // Configure HTML load options
        var options = new HtmlLoadOptions(url)
        {
            // Enable external resources loading
            ExternalResourcesCredentials = credentials,

            // Set page info
            PageInfo = new PageInfo
            {
                Width = PageSize.A4.Width,
                Height = PageSize.A4.Height,
                Margin = new MarginInfo(20, 20, 20, 20) // left, bottom, right, top
            },

            // Enable JavaScript execution (limited support)
            IsEmbedFonts = true,
            IsRenderToSinglePage = false
        };

        try
        {
            // Fetch HTML content as stream and load into Document
            using (var document = new Document(GetContentFromUrlAsStream(url, credentials), options))
            {
                // Add metadata
                document.Info.Title = "Wikipedia Main Page";
                document.Info.Author = "Aspose.PDF Example";
                document.Info.Subject = "URL to PDF Conversion";
                document.Info.Keywords = "PDF, Aspose, Wikipedia";

                // Improve the PDF
                document.OptimizeResources();

                // Save PDF with specific save options
                var saveOptions = new PdfSaveOptions
                {
                    DefaultFontName = "Arial", // Fallback font
                    EmbedStandardFonts = true
                };

                document.Save("aspose-output.pdf", saveOptions);
            }

            Console.WriteLine("PDF successfully created!");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }

    private static Stream GetContentFromUrlAsStream(string url, ICredentials credentials = null)
    {
        using var handler = new System.Net.Http.HttpClientHandler { Credentials = credentials };
        using var httpClient = new System.Net.Http.HttpClient(handler);

        // Set a browser-like User-Agent to avoid 403 errors
        httpClient.DefaultRequestHeaders.Add("User-Agent",
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " +
            "(KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36");

        // Set timeout
        httpClient.Timeout = TimeSpan.FromSeconds(30);

        return httpClient.GetStreamAsync(url).GetAwaiter().GetResult();
    }
}
Imports Aspose.Pdf
Imports System
Imports System.IO
Imports System.Net
Imports System.Net.Http

Class Program
    Shared Sub Main()
        Dim url As String = "___PROTECTED_URL_172___"

        ' Optional: provide credentials for protected resources
        Dim credentials As NetworkCredential = Nothing
        ' Example for authenticated resources:
        ' credentials = New NetworkCredential("username", "password")

        ' Configure HTML load options
        Dim options As New HtmlLoadOptions(url) With {
            .ExternalResourcesCredentials = credentials,
            .PageInfo = New PageInfo With {
                .Width = PageSize.A4.Width,
                .Height = PageSize.A4.Height,
                .Margin = New MarginInfo(20, 20, 20, 20) ' left, bottom, right, top
            },
            .IsEmbedFonts = True,
            .IsRenderToSinglePage = False
        }

        Try
            ' Fetch HTML content as stream and load into Document
            Using document As New Document(GetContentFromUrlAsStream(url, credentials), options)
                ' Add metadata
                document.Info.Title = "Wikipedia Main Page"
                document.Info.Author = "Aspose.PDF Example"
                document.Info.Subject = "URL to PDF Conversion"
                document.Info.Keywords = "PDF, Aspose, Wikipedia"

                ' Improve the PDF
                document.OptimizeResources()

                ' Save PDF with specific save options
                Dim saveOptions As New PdfSaveOptions With {
                    .DefaultFontName = "Arial", ' Fallback font
                    .EmbedStandardFonts = True
                }

                document.Save("aspose-output.pdf", saveOptions)
            End Using

            Console.WriteLine("PDF successfully created!")
        Catch ex As Exception
            Console.WriteLine($"Error: {ex.Message}")
        End Try
    End Sub

    Private Shared Function GetContentFromUrlAsStream(url As String, Optional credentials As ICredentials = Nothing) As Stream
        Using handler As New HttpClientHandler With {.Credentials = credentials}
            Using httpClient As New HttpClient(handler)
                ' Set a browser-like User-Agent to avoid 403 errors
                httpClient.DefaultRequestHeaders.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " &
                                                     "(KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36")

                ' Set timeout
                httpClient.Timeout = TimeSpan.FromSeconds(30)

                Return httpClient.GetStreamAsync(url).GetAwaiter().GetResult()
            End Using
        End Using
    End Function
End Class
$vbLabelText   $csharpLabel

Screenshot der Wikipedia-Startseite mit Hauptlayout, Artikel über 20 Exchange Place, Rubrik

Dieser Code ruft HTML-Inhalte mithilfe eines browserähnlichen User-Agents ab, um 403-Fehler zu vermeiden, streamt HTML direkt in ein Aspose.PDF-Dokument mit HtmlLoadOptions und speichert es anschließend als PDF. Das Ergebnis erhält Seitenlayout, Text, Bilder und CSS-Stile mit grundlegender HTTP-Authentifizierungsunterstützung. Dynamische JavaScript Inhalte werden nicht ausgeführt. Für eine bessere JavaScript Unterstützung sollten Sie die JavaScript -Rendering-Funktionen von IronPDF erkunden.

Fazit: Aspose.PDF eignet sich hervorragend für Enterprise , die erweiterte Funktionen, Multi-Format-Konvertierung und hohe Sicherheit erfordern. Obwohl es für kleinere Projekte kommerziell und unter Umständen komplex sein kann, ist es für große Dokumentenworkflows unübertroffen.

Was ist Syncfusion PDF und wann sollte man es verwenden?

Syncfusion PDF ist Teil der Syncfusion Suite und bietet eine funktionsreiche .NET PDF-Bibliothek für Web- und Desktop-Anwendungen. Die Bibliothek übernimmt für Sie die Komplexität beim Generieren, Bearbeiten und Konvertieren von PDFs, einschließlich der HTML-zu-PDF-Konvertierung, und integriert sich gleichzeitig nahtlos in andere Syncfusion Komponenten für Berichte und Dashboards. Teams, die Syncfusion Komponenten nutzen, profitieren von einer engen Integration. Sehen Sie sich unseren Vergleich zwischen Syncfusion und IronPDF an.

Warum sollten Sie Syncfusion für integrierte Lösungen in Betracht ziehen?

Wie konvertiert Syncfusion URLs in PDF?

using Syncfusion.HtmlConverter;
using Syncfusion.Pdf;

class Program
{
    static void Main()
    {
        // Initialize the HTML to PDF converter
        HtmlToPdfConverter converter = new HtmlToPdfConverter();

        // Configure WebKit settings for better rendering
        WebKitConverterSettings settings = new WebKitConverterSettings();

        // Set WebKit path (required for deployment)
        settings.WebKitPath = @"C:\QtBinariesPath";

        // Configure page settings
        settings.PdfPageSize = PdfPageSize.A4;
        settings.Orientation = PdfPageOrientation.Portrait;
        settings.Margin = new PdfMargins() { All = 20 };

        // Enable JavaScript execution
        settings.EnableJavaScript = true;
        settings.JavaScriptDelay = 3000; // Wait 3 seconds for JS

        // Set viewport size for responsive design
        settings.ViewPortSize = new System.Drawing.Size(1024, 0);

        // Add custom headers if needed
        settings.HttpRequestHeaders.Add("User-Agent", 
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36");

        converter.ConverterSettings = settings;

        // Convert URL to PDF
        PdfDocument document = converter.Convert("___PROTECTED_URL_173___");

        // Add document info
        document.DocumentInformation.Title = "Wikipedia Main Page";
        document.DocumentInformation.Author = "Syncfusion Example";
        document.DocumentInformation.Subject = "URL to PDF Conversion";

        // Save the PDF
        document.Save("syncfusion-output.pdf");
        document.Close(true); // true = dispose resources

        Console.WriteLine("PDF created successfully!");
    }
}
using Syncfusion.HtmlConverter;
using Syncfusion.Pdf;

class Program
{
    static void Main()
    {
        // Initialize the HTML to PDF converter
        HtmlToPdfConverter converter = new HtmlToPdfConverter();

        // Configure WebKit settings for better rendering
        WebKitConverterSettings settings = new WebKitConverterSettings();

        // Set WebKit path (required for deployment)
        settings.WebKitPath = @"C:\QtBinariesPath";

        // Configure page settings
        settings.PdfPageSize = PdfPageSize.A4;
        settings.Orientation = PdfPageOrientation.Portrait;
        settings.Margin = new PdfMargins() { All = 20 };

        // Enable JavaScript execution
        settings.EnableJavaScript = true;
        settings.JavaScriptDelay = 3000; // Wait 3 seconds for JS

        // Set viewport size for responsive design
        settings.ViewPortSize = new System.Drawing.Size(1024, 0);

        // Add custom headers if needed
        settings.HttpRequestHeaders.Add("User-Agent", 
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36");

        converter.ConverterSettings = settings;

        // Convert URL to PDF
        PdfDocument document = converter.Convert("___PROTECTED_URL_173___");

        // Add document info
        document.DocumentInformation.Title = "Wikipedia Main Page";
        document.DocumentInformation.Author = "Syncfusion Example";
        document.DocumentInformation.Subject = "URL to PDF Conversion";

        // Save the PDF
        document.Save("syncfusion-output.pdf");
        document.Close(true); // true = dispose resources

        Console.WriteLine("PDF created successfully!");
    }
}
Imports Syncfusion.HtmlConverter
Imports Syncfusion.Pdf
Imports System.Drawing

Class Program
    Shared Sub Main()
        ' Initialize the HTML to PDF converter
        Dim converter As New HtmlToPdfConverter()

        ' Configure WebKit settings for better rendering
        Dim settings As New WebKitConverterSettings()

        ' Set WebKit path (required for deployment)
        settings.WebKitPath = "C:\QtBinariesPath"

        ' Configure page settings
        settings.PdfPageSize = PdfPageSize.A4
        settings.Orientation = PdfPageOrientation.Portrait
        settings.Margin = New PdfMargins() With {.All = 20}

        ' Enable JavaScript execution
        settings.EnableJavaScript = True
        settings.JavaScriptDelay = 3000 ' Wait 3 seconds for JS

        ' Set viewport size for responsive design
        settings.ViewPortSize = New Size(1024, 0)

        ' Add custom headers if needed
        settings.HttpRequestHeaders.Add("User-Agent", 
                                        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")

        converter.ConverterSettings = settings

        ' Convert URL to PDF
        Dim document As PdfDocument = converter.Convert("___PROTECTED_URL_173___")

        ' Add document info
        document.DocumentInformation.Title = "Wikipedia Main Page"
        document.DocumentInformation.Author = "Syncfusion Example"
        document.DocumentInformation.Subject = "URL to PDF Conversion"

        ' Save the PDF
        document.Save("syncfusion-output.pdf")
        document.Close(True) ' true = dispose resources

        Console.WriteLine("PDF created successfully!")
    End Sub
End Class
$vbLabelText   $csharpLabel

Was sind die Stärken von Syncfusion im Bereich Reporting?

PDF-Viewer, der Wikipedia-Inhalte mit einem auffälligen roten diagonalen Wasserzeichen der Syncfusion Testversion anzeigt, das die gesamte Seite überlagert

Dieses Beispiel wandelt URLs in PDFs um und erhält dabei Layout, Bilder und Formatierung. Syncfusion PDF eignet sich hervorragend für Berichtsszenarien, die eine zuverlässige HTML-zu-PDF-Konvertierung erfordern. Die Bibliothek unterstützt Kopf- und Fußzeilen , Seitenzahlen und Lesezeichen für Professional Dokumente.

Fazit: Syncfusion PDF eignet sich hervorragend für Teams, die Syncfusion Komponenten verwenden, eine Professional HTML-zu-PDF-Wiedergabe benötigen oder eine Enterprise PDF-Generierung mit umfangreichen Funktionen wünschen. Alternativen finden Sie in unserem detaillierten Vergleich .

Was ist QuestPDF und wann sollte man es verwenden?

QuestPDF ist eine Open-Source-C#-Bibliothek, die sich auf die programmatische PDF-Generierung mittels einer deklarativen API konzentriert. Im Gegensatz zu HTML-zu-PDF-Konvertern erstellt QuestPDF PDFs vollständig im Code und bietet so eine präzise Kontrolle über Layout, Text, Bilder und Tabellen. Ihre Anwendung kann diese Funktion sofort für automatisierte Berichte, Rechnungen und strukturierte Dokumente nutzen, die dynamisch generiert werden. Sehen Sie sich unseren Vergleich zwischen QuestPDF und IronPDF an.

Warum QuestPDF für die programmatische Steuerung wählen?

Wie erstellt man PDFs mit der Fluent API von QuestPDF?

using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;
using QuestPDF.Previewer;

class Program
{
    static void Main()
    {
        // Configure license (Community, Professional, or Enterprise)
        QuestPDF.Settings.License = LicenseType.Community;

        // Create document with fluent API
        Document.Create(container =>
        {
            container.Page(page =>
            {
                // Page settings
                page.Size(PageSizes.A4);
                page.Margin(2, Unit.Centimetre);
                page.PageColor(Colors.White);
                page.DefaultTextStyle(x => x.FontSize(12).FontFamily(Fonts.Arial));

                // Header section
                page.Header()
                    .Height(100)
                    .Background(Colors.Grey.Lighten3)
                    .AlignCenter()
                    .AlignMiddle()
                    .Text("QuestPDF Example Document")
                    .FontSize(20)
                    .Bold()
                    .FontColor(Colors.Blue.Darken2);

                // Content section
                page.Content()
                    .PaddingVertical(1, Unit.Centimetre)
                    .Column(column =>
                    {
                        column.Spacing(20);

                        // Add title
                        column.Item().Text("Hello from QuestPDF!")
                            .FontSize(16)
                            .SemiBold()
                            .FontColor(Colors.Blue.Medium);

                        // Add paragraph
                        column.Item().Text(text =>
                        {
                            text.Span("This is an example of programmatic PDF generation using ");
                            text.Span("QuestPDF").Bold();
                            text.Span(". You have complete control over layout and styling.");
                        });

                        // Add table
                        column.Item().Table(table =>
                        {
                            table.ColumnsDefinition(columns =>
                            {
                                columns.RelativeColumn();
                                columns.RelativeColumn();
                            });

                            // Table header
                            table.Header(header =>
                            {
                                header.Cell().Background(Colors.Grey.Medium)
                                    .Padding(5).Text("Feature").Bold();
                                header.Cell().Background(Colors.Grey.Medium)
                                    .Padding(5).Text("Description").Bold();
                            });

                            // Table rows
                            table.Cell().Border(1).Padding(5).Text("Fluent API");
                            table.Cell().Border(1).Padding(5)
                                .Text("Build documents using method chaining");

                            table.Cell().Border(1).Padding(5).Text("Layout Control");
                            table.Cell().Border(1).Padding(5)
                                .Text("Precise control over element positioning");
                        });
                    });

                // Footer section
                page.Footer()
                    .Height(50)
                    .AlignCenter()
                    .Text(text =>
                    {
                        text.Span("Page ");
                        text.CurrentPageNumber();
                        text.Span(" of ");
                        text.TotalPages();
                    });
            });
        })
        .GeneratePdf("questpdf-output.pdf");

        Console.WriteLine("PDF created with QuestPDF!");
    }
}
using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;
using QuestPDF.Previewer;

class Program
{
    static void Main()
    {
        // Configure license (Community, Professional, or Enterprise)
        QuestPDF.Settings.License = LicenseType.Community;

        // Create document with fluent API
        Document.Create(container =>
        {
            container.Page(page =>
            {
                // Page settings
                page.Size(PageSizes.A4);
                page.Margin(2, Unit.Centimetre);
                page.PageColor(Colors.White);
                page.DefaultTextStyle(x => x.FontSize(12).FontFamily(Fonts.Arial));

                // Header section
                page.Header()
                    .Height(100)
                    .Background(Colors.Grey.Lighten3)
                    .AlignCenter()
                    .AlignMiddle()
                    .Text("QuestPDF Example Document")
                    .FontSize(20)
                    .Bold()
                    .FontColor(Colors.Blue.Darken2);

                // Content section
                page.Content()
                    .PaddingVertical(1, Unit.Centimetre)
                    .Column(column =>
                    {
                        column.Spacing(20);

                        // Add title
                        column.Item().Text("Hello from QuestPDF!")
                            .FontSize(16)
                            .SemiBold()
                            .FontColor(Colors.Blue.Medium);

                        // Add paragraph
                        column.Item().Text(text =>
                        {
                            text.Span("This is an example of programmatic PDF generation using ");
                            text.Span("QuestPDF").Bold();
                            text.Span(". You have complete control over layout and styling.");
                        });

                        // Add table
                        column.Item().Table(table =>
                        {
                            table.ColumnsDefinition(columns =>
                            {
                                columns.RelativeColumn();
                                columns.RelativeColumn();
                            });

                            // Table header
                            table.Header(header =>
                            {
                                header.Cell().Background(Colors.Grey.Medium)
                                    .Padding(5).Text("Feature").Bold();
                                header.Cell().Background(Colors.Grey.Medium)
                                    .Padding(5).Text("Description").Bold();
                            });

                            // Table rows
                            table.Cell().Border(1).Padding(5).Text("Fluent API");
                            table.Cell().Border(1).Padding(5)
                                .Text("Build documents using method chaining");

                            table.Cell().Border(1).Padding(5).Text("Layout Control");
                            table.Cell().Border(1).Padding(5)
                                .Text("Precise control over element positioning");
                        });
                    });

                // Footer section
                page.Footer()
                    .Height(50)
                    .AlignCenter()
                    .Text(text =>
                    {
                        text.Span("Page ");
                        text.CurrentPageNumber();
                        text.Span(" of ");
                        text.TotalPages();
                    });
            });
        })
        .GeneratePdf("questpdf-output.pdf");

        Console.WriteLine("PDF created with QuestPDF!");
    }
}
Imports QuestPDF.Fluent
Imports QuestPDF.Helpers
Imports QuestPDF.Infrastructure
Imports QuestPDF.Previewer

Module Program
    Sub Main()
        ' Configure license (Community, Professional, or Enterprise)
        QuestPDF.Settings.License = LicenseType.Community

        ' Create document with fluent API
        Document.Create(Sub(container)
                            container.Page(Sub(page)
                                               ' Page settings
                                               page.Size(PageSizes.A4)
                                               page.Margin(2, Unit.Centimetre)
                                               page.PageColor(Colors.White)
                                               page.DefaultTextStyle(Function(x) x.FontSize(12).FontFamily(Fonts.Arial))

                                               ' Header section
                                               page.Header() _
                                                   .Height(100) _
                                                   .Background(Colors.Grey.Lighten3) _
                                                   .AlignCenter() _
                                                   .AlignMiddle() _
                                                   .Text("QuestPDF Example Document") _
                                                   .FontSize(20) _
                                                   .Bold() _
                                                   .FontColor(Colors.Blue.Darken2)

                                               ' Content section
                                               page.Content() _
                                                   .PaddingVertical(1, Unit.Centimetre) _
                                                   .Column(Sub(column)
                                                               column.Spacing(20)

                                                               ' Add title
                                                               column.Item().Text("Hello from QuestPDF!") _
                                                                   .FontSize(16) _
                                                                   .SemiBold() _
                                                                   .FontColor(Colors.Blue.Medium)

                                                               ' Add paragraph
                                                               column.Item().Text(Sub(text)
                                                                                      text.Span("This is an example of programmatic PDF generation using ")
                                                                                      text.Span("QuestPDF").Bold()
                                                                                      text.Span(". You have complete control over layout and styling.")
                                                                                  End Sub)

                                                               ' Add table
                                                               column.Item().Table(Sub(table)
                                                                                       table.ColumnsDefinition(Sub(columns)
                                                                                                                   columns.RelativeColumn()
                                                                                                                   columns.RelativeColumn()
                                                                                                               End Sub)

                                                                                       ' Table header
                                                                                       table.Header(Sub(header)
                                                                                                       header.Cell().Background(Colors.Grey.Medium) _
                                                                                                           .Padding(5).Text("Feature").Bold()
                                                                                                       header.Cell().Background(Colors.Grey.Medium) _
                                                                                                           .Padding(5).Text("Description").Bold()
                                                                                                   End Sub)

                                                                                       ' Table rows
                                                                                       table.Cell().Border(1).Padding(5).Text("Fluent API")
                                                                                       table.Cell().Border(1).Padding(5) _
                                                                                           .Text("Build documents using method chaining")

                                                                                       table.Cell().Border(1).Padding(5).Text("Layout Control")
                                                                                       table.Cell().Border(1).Padding(5) _
                                                                                           .Text("Precise control over element positioning")
                                                                                   End Sub)
                                                           End Sub)

                                               ' Footer section
                                               page.Footer() _
                                                   .Height(50) _
                                                   .AlignCenter() _
                                                   .Text(Sub(text)
                                                             text.Span("Page ")
                                                             text.CurrentPageNumber()
                                                             text.Span(" of ")
                                                             text.TotalPages()
                                                         End Sub)
                                           End Sub)
                        End Sub) _
            .GeneratePdf("questpdf-output.pdf")

        Console.WriteLine("PDF created with QuestPDF!")
    End Sub
End Module
$vbLabelText   $csharpLabel

Wann erzielt QuestPDF hervorragende Ergebnisse?

PDF-Viewer, der ein von QuestPDF generiertes Dokument mit dem Text

Dies demonstriert die programmgesteuerte PDF-Erstellung mit voller Kontrolle über Inhalt und Layout ohne HTML-Eingabe. QuestPDF eignet sich hervorragend zum Erstellen von Rechnungen , Formularen und strukturierten Berichten, die eine präzise Positionierung erfordern. Für Teams, die eine ähnliche Steuerung mit HTML-Unterstützung benötigen, empfiehlt sich ein Blick auf die programmatischen Funktionen von IronPDF .

Fazit: QuestPDF ist perfekt für Entwickler, die die volle programmatische Kontrolle über PDF-Inhalte benötigen. Obwohl es keine HTML-Konvertierung bietet, eignet es sich hervorragend für strukturierte, dynamisch generierte PDFs für Berichterstellung und Automatisierung.

Welche C# PDF-Bibliothek sollten Sie wählen?

Die Auswahl der richtigen C# PDF-Bibliothek hängt von den Anforderungen Ihres Projekts und dem Inhaltstyp ab. Für dynamische Webinhalte mit komplexem CSS oder JavaScript bietet IronPDF die zuverlässigste Lösung mit hochauflösender Darstellung und einfachen APIs. Für Enterprise , die PDF/A-Konformität , digitale Signaturen oder die Konvertierung mehrerer Formate erfordern, bieten iText 7 und Aspose.PDF umfangreiche Funktionen, hohe Sicherheit und umfassenden Support.

Open-Source-Bibliotheken wie PDFSharp/MigraDoc und QuestPDF eignen sich hervorragend für Entwickler, die eine programmatische Kontrolle über Dokumentlayout und -inhalt bevorzugen, und sind perfekt geeignet, um strukturierte Berichte, Rechnungen oder Tickets ohne HTML zu generieren. Syncfusion PDF bietet eine funktionsreiche Umgebung für Berichte und Dashboards, während wkhtmltopdf sich durch die Konvertierung statischer Webseiten in PDFs mit hoher CSS-Genauigkeit auszeichnet.

Wie beurteilt man die Bereitschaft eines Enterprise ?

Bei der Bewertung der Bereitschaft von Enterprise sollten folgende Faktoren berücksichtigt werden:

Support & SLAs : IronPDF bietet technischen Support rund um die Uhr an 5 Tagen die Woche mit garantierten Reaktionszeiten. Kommerzielle Bibliotheken wie iText 7 und Aspose bieten Supportpakete für Enterprise an. Open-Source-Lösungen sind auf die Unterstützung der Community angewiesen. Weitere Unterstützung finden Sie in den Richtlinien für technischen Support und in den Best Practices für Support .

Sicherheit & Compliance : IronPDF unterstützt PDF/A , PDF/UA , Verschlüsselung und digitale Signaturen . Die Bibliothek wird regelmäßigen Sicherheitsüberprüfungen unterzogen und erfüllt die Anforderungen von SOC 2. Für Enterprise Signing siehe HSM-Integration .

Leistung und Skalierbarkeit : Die Chrome-Engine von IronPDF bewältigt asynchrone Operationen und Multithreading effizient. Bei Szenarien mit hohem Datenaufkommen sollten Sie Strategien zur Leistungsoptimierung und Parallelverarbeitung in Betracht ziehen.

Gesamtbetriebskosten : Bei Open-Source-Optionen fallen zwar keine Lizenzgebühren an, jedoch sollten Sie den Zeitaufwand der Entwickler sowie die Kosten für Wartung und Support berücksichtigen. Die Lizenzierung von IronPDF beinhaltet Updates und Support, wodurch die langfristigen Kosten reduziert werden. Entdecken Sie Erweiterungen für laufende Projekte. ## Warum sollten Sie IronPDF noch heute ausprobieren?

Sind Sie bereit, die PDF-Erstellung, -Bearbeitung und HTML-zu-PDF-Konvertierung in Ihren .NET Anwendungen zu vereinfachen? Dank der benutzerfreundlichen API, der hochwertigen Darstellung und des Professional Supports können Sie schnell loslegen und sofort Ergebnisse sehen. Entdecken Sie unsere vollständige Dokumentation , Codebeispiele und API-Referenz , um die Entwicklung zu beschleunigen. In unserem Änderungsprotokoll finden Sie die neuesten Updates und Meilensteine ​​für wichtige Verbesserungen.

Starten Sie noch heute Ihre kostenlose Testphase und entdecken Sie, warum IronPDF die bevorzugte Wahl für Entwickler ist, die moderne .NET PDF-Anwendungen erstellen. Für Teams, die bereit für den Einsatz sind, bieten wir Lizenzoptionen mit transparenter Preisgestaltung und flexibler Bereitstellung auf Windows , Linux , Docker , macOS und Cloud-Plattformen wie Azure und AWS . Weitere Informationen zu zusätzlichen PDF-Sicherheitsfunktionen finden Sie in der IronWord -Dokumentation und der IronSecureDoc -Dokumentation .

{i:(iText, PDFSharp, Aspose, Syncfusion und QuestPDF sind eingetragene Marken der jeweiligen Eigentümer. Diese Seite ist nicht mit iText, PDFSharp, Aspose, Syncfusion oder QuestPDF verbunden, wird nicht von ihnen unterstützt oder gesponsert. 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

Was ist die beste C# PDF-Bibliothek zur Erstellung von Rechnungen?

IronPDF ist aufgrund seiner robusten Funktionen und der einfachen Integration in .NET-Anwendungen eine beliebte Wahl zur Erstellung von Rechnungen.

Wie vergleicht sich IronPDF mit iText bei der PDF-Erstellung?

IronPDF bietet eine einfachere API und umfassende Dokumentation, was die Integration und Nutzung im Vergleich zu iText für Entwickler erleichtert.

Kann ich IronPDF zur Umwandlung von Berichten in PDFs verwenden?

Ja, IronPDF eignet sich hervorragend zur effizienten Umwandlung verschiedener Berichtstypen in das PDF-Format.

Ist IronPDF mit modernen .NET-Anwendungen kompatibel?

IronPDF ist voll kompatibel mit modernen .NET-Anwendungen und ermöglicht eine nahtlose Integration für Entwickler.

Was sind die Vorteile der Verwendung von IronPDF gegenüber PDFSharp?

IronPDF bietet fortschrittlichere Funktionen und bessere Unterstützung für moderne .NET-Umgebungen im Vergleich zu PDFSharp.

Unterstützt IronPDF die Integration von Formularen in Webanwendungen?

Ja, IronPDF unterstützt die Formularintegration in Webanwendungen und bietet Tools zur Handhabung von Formulardaten und PDF-Interaktionen.

Welche PDF-Bibliothek ist für Anfänger in C# am besten geeignet?

IronPDF ist benutzerfreundlich und bietet umfassende Dokumentation, wodurch es eine ausgezeichnete Wahl für Anfänger in C# ist.

Wie vergleicht sich die Preisgestaltung von IronPDF mit anderen PDF-Bibliotheken?

IronPDF bietet wettbewerbsfähige Preise mit verschiedenen Lizenzoptionen und stellt oft einen besseren Wert im Vergleich zu anderen Premium-PDF-Bibliotheken dar.

Kann IronPDF umfangreiche PDF-Verarbeitungsaufgaben bewältigen?

Ja, IronPDF ist darauf ausgelegt, umfangreiche PDF-Verarbeitungsaufgaben effizient zu bewältigen und eignet sich daher für Projekte auf Unternehmensebene.

Welche Unterstützungsoptionen stehen IronPDF-Nutzern zur Verfügung?

IronPDF bietet umfassende Unterstützung, einschließlich Dokumentation, Tutorials und reaktionsschnellem Kundenservice, um Nutzern zu helfen.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
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

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

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