Iron Suite for .NET

10 .NET-Bibliotheken. Eine komplette Dokumenten-Suite.

Entdecken Sie Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

VERGLEICH

PDFFilePrint gegen IronPDF: Leitfaden für einen technischen Vergleich

Curtis Chau

Updated: 28. Juni 2026

Wenn .NET-Entwickler Lösungen für den Dokumentendruck und die PDF-Erzeugung bewerten, bieten RawPrint .NETund IronPDF grundlegend unterschiedliche Ansätze mit unterschiedlichen Funktionen. RawPrint .NETbietet Low-Level-Zugriff auf Drucker-Spooler, um Raw-Bytes direkt an Drucker zu senden, während IronPDF eine vollständige High-Level-API zum Erstellen, Bearbeiten und Drucken von PDF-Dokumenten bietet. In diesem technischen Vergleich werden beide Lösungen in den Bereichen untersucht, die für professionelle Entwickler und Architekten, die Entscheidungen über die Dokumentenverarbeitung for .NET-Anwendungen treffen, am wichtigsten sind.

RawPrint .NETverstehen

RawPrint .NET ist ein Low-Level-Druckdienstprogramm, das Rohbytes direkt an Drucker-Spooler sendet. Es ermöglicht Anwendungen, herkömmliche Druckertreiber zu umgehen und Befehlsdaten direkt an Drucker zu übertragen. Diese Funktionalität ist besonders nützlich für spezialisierte Drucker, wie z. B. für Etikettenersteller, die ZPL (Zebra Programming Language) oder EPL (Eltron Programming Language) verwenden.

Kritisches Unterscheidungsmerkmal: RawPrint .NETist keine PDF-Bibliothek. Es werden keine PDF-Dokumente erstellt, generiert, gerendert oder manipuliert. Ihre einzige Funktion ist die Übertragung von Bytes an die Druckerhardware über das Windows-Drucksubsystem.

Der Ansatz erfordert, dass Entwickler mit Windows-spezifischen DLL-Importen von winspool.Drv arbeiten und Druckergriffe manuell durch eine Reihe von Funktionsaufrufen verwalten: OpenPrinter, StartDocPrinter, StartPagePrinter, WritePrinter, EndPagePrinter, EndDocPrinter und ClosePrinter.

Die Architektur von RawPrint .NETerfordert ein tiefes Verständnis der Druckerbefehlssprachen. Für die Formatierung der Dokumente müssen die Entwickler manuelle PCL- (Printer Command Language) oder PostScript-Befehle als Escape-Sequenzen konstruieren, die in den Bytestrom eingebettet sind.

IronPDF verstehen

IronPDF bietet eine vollständige High-Level-API für PDF-Vorgänge in .NET-Anwendungen. Die Bibliothek enthält eine Chromium-basierte Rendering-Engine, die HTML, CSS und JavaScript originalgetreu in PDF-Dokumente umwandelt. Neben der Generierung bietet IronPDF auch Funktionen zur PDF-Bearbeitung, einschließlich Zusammenführen, Aufteilen, Bearbeiten und Sicherheitsfunktionen.

Die Architektur von IronPDF abstrahiert die Komplexität der Dokumentendarstellung und der Druckerkommunikation. Die ChromePdfRenderer-Klasse übernimmt die HTML-zu-PDF-Konvertierung, während die PdfDocument-Klasse Methoden für die Manipulation und den Druck bereitstellt, ohne dass eine manuelle Ressourcenverwaltung erforderlich ist.

Die Lücke bei den Kernkompetenzen

Der grundlegende Unterschied zwischen RawPrint .NETund IronPDF liegt in ihrem Zweck und ihren Fähigkeiten:

Aufgabe	RawPrint .NET	IronPDF
PDF aus HTML erstellen	Nicht unterstützt	Ja
PDF aus URL erstellen	Nicht unterstützt	Ja
Bearbeiten/Ändern von PDFs	Nicht unterstützt	Ja
PDFs zusammenführen/teilen	Nicht unterstützt	Ja
Vorhandene PDF-Datei drucken	Ja (nur Rohbytes)	Ja (API auf hoher Ebene)
Drucksteuerung	Basic	Vollständige Optionen
Plattformübergreifend	Nur für Windows	Ja

Dieser Vergleich zeigt, dass RawPrint .NETund IronPDF völlig unterschiedliche Anwendungsfälle bedienen. RawPrint .NETbefasst sich mit der Low-Level-Druckerkommunikation, während IronPDF eine vollständige Verwaltung des Lebenszyklus von PDF-Dokumenten bietet.

HTML zu PDF Konvertierung

Der Kontrast zwischen RawPrint .NETund IronPDF wird deutlich, wenn man die Konvertierungsszenarien von HTML in PDF betrachtet.

RawPrint .NETHTML-Behandlung

RawPrint .NET kann HTML nicht in PDF konvertieren. Es können nur Rohdaten an Drucker gesendet werden:

// NuGet: Install-Package System.Drawing.Common
using System;
using System.Drawing;
using System.Drawing.Printing;
using System.Runtime.InteropServices;
using System.Text;

class RawPrinterHelper
{
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public class DOCINFOA
    {
        [MarshalAs(UnmanagedType.LPStr)] public string pDocName;
        [MarshalAs(UnmanagedType.LPStr)] public string pOutputFile;
        [MarshalAs(UnmanagedType.LPStr)] public string pDataType;
    }

    [DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool OpenPrinter([MarshalAs(UnmanagedType.LPStr)] string szPrinter, out IntPtr hPrinter, IntPtr pd);

    [DllImport("winspool.Drv", EntryPoint = "ClosePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool ClosePrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", EntryPoint = "StartDocPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool StartDocPrinter(IntPtr hPrinter, Int32 level, [In, MarshalAs(UnmanagedType.LPStruct)] DOCINFOA di);

    [DllImport("winspool.Drv", EntryPoint = "EndDocPrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool EndDocPrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", EntryPoint = "StartPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool StartPagePrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", EntryPoint = "EndPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool EndPagePrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", EntryPoint = "WritePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool WritePrinter(IntPtr hPrinter, IntPtr pBytes, Int32 dwCount, out Int32 dwWritten);

    public static bool SendStringToPrinter(string szPrinterName, string szString)
    {
        IntPtr pBytes;
        Int32 dwCount;
        dwCount = szString.Length;
        pBytes = Marshal.StringToCoTaskMemAnsi(szString);
        IntPtr hPrinter;
        if (OpenPrinter(szPrinterName, out hPrinter, IntPtr.Zero))
        {
            DOCINFOA di = new DOCINFOA();
            di.pDocName = "HTML Document";
            di.pDataType = "RAW";
            if (StartDocPrinter(hPrinter, 1, di))
            {
                if (StartPagePrinter(hPrinter))
                {
                    Int32 dwWritten;
                    WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                    EndPagePrinter(hPrinter);
                }
                EndDocPrinter(hPrinter);
            }
            ClosePrinter(hPrinter);
            Marshal.FreeCoTaskMem(pBytes);
            return true;
        }
        return false;
    }
}

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Hello World</h1></body></html>";
        // RawPrint cannot directly convert HTML to PDF
        // It sends raw data to printer, no PDF generation capability
        RawPrinterHelper.SendStringToPrinter("Microsoft Print to PDF", html);
    }
}

// NuGet: Install-Package System.Drawing.Common
using System;
using System.Drawing;
using System.Drawing.Printing;
using System.Runtime.InteropServices;
using System.Text;

class RawPrinterHelper
{
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public class DOCINFOA
    {
        [MarshalAs(UnmanagedType.LPStr)] public string pDocName;
        [MarshalAs(UnmanagedType.LPStr)] public string pOutputFile;
        [MarshalAs(UnmanagedType.LPStr)] public string pDataType;
    }

    [DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool OpenPrinter([MarshalAs(UnmanagedType.LPStr)] string szPrinter, out IntPtr hPrinter, IntPtr pd);

    [DllImport("winspool.Drv", EntryPoint = "ClosePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool ClosePrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", EntryPoint = "StartDocPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool StartDocPrinter(IntPtr hPrinter, Int32 level, [In, MarshalAs(UnmanagedType.LPStruct)] DOCINFOA di);

    [DllImport("winspool.Drv", EntryPoint = "EndDocPrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool EndDocPrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", EntryPoint = "StartPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool StartPagePrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", EntryPoint = "EndPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool EndPagePrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", EntryPoint = "WritePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool WritePrinter(IntPtr hPrinter, IntPtr pBytes, Int32 dwCount, out Int32 dwWritten);

    public static bool SendStringToPrinter(string szPrinterName, string szString)
    {
        IntPtr pBytes;
        Int32 dwCount;
        dwCount = szString.Length;
        pBytes = Marshal.StringToCoTaskMemAnsi(szString);
        IntPtr hPrinter;
        if (OpenPrinter(szPrinterName, out hPrinter, IntPtr.Zero))
        {
            DOCINFOA di = new DOCINFOA();
            di.pDocName = "HTML Document";
            di.pDataType = "RAW";
            if (StartDocPrinter(hPrinter, 1, di))
            {
                if (StartPagePrinter(hPrinter))
                {
                    Int32 dwWritten;
                    WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                    EndPagePrinter(hPrinter);
                }
                EndDocPrinter(hPrinter);
            }
            ClosePrinter(hPrinter);
            Marshal.FreeCoTaskMem(pBytes);
            return true;
        }
        return false;
    }
}

class Program
{
    static void Main()
    {
        string html = "<html><body><h1>Hello World</h1></body></html>";
        // RawPrint cannot directly convert HTML to PDF
        // It sends raw data to printer, no PDF generation capability
        RawPrinterHelper.SendStringToPrinter("Microsoft Print to PDF", html);
    }
}

Imports System
Imports System.Drawing
Imports System.Drawing.Printing
Imports System.Runtime.InteropServices
Imports System.Text

Class RawPrinterHelper
    <StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Ansi)>
    Public Class DOCINFOA
        <MarshalAs(UnmanagedType.LPStr)> Public pDocName As String
        <MarshalAs(UnmanagedType.LPStr)> Public pOutputFile As String
        <MarshalAs(UnmanagedType.LPStr)> Public pDataType As String
    End Class

    <DllImport("winspool.Drv", EntryPoint:="OpenPrinterA", SetLastError:=True, CharSet:=CharSet.Ansi, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function OpenPrinter(<MarshalAs(UnmanagedType.LPStr)> szPrinter As String, ByRef hPrinter As IntPtr, pd As IntPtr) As Boolean
    End Function

    <DllImport("winspool.Drv", EntryPoint:="ClosePrinter", SetLastError:=True, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function ClosePrinter(hPrinter As IntPtr) As Boolean
    End Function

    <DllImport("winspool.Drv", EntryPoint:="StartDocPrinterA", SetLastError:=True, CharSet:=CharSet.Ansi, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function StartDocPrinter(hPrinter As IntPtr, level As Integer, <[In], MarshalAs(UnmanagedType.LPStruct)> di As DOCINFOA) As Boolean
    End Function

    <DllImport("winspool.Drv", EntryPoint:="EndDocPrinter", SetLastError:=True, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function EndDocPrinter(hPrinter As IntPtr) As Boolean
    End Function

    <DllImport("winspool.Drv", EntryPoint:="StartPagePrinter", SetLastError:=True, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function StartPagePrinter(hPrinter As IntPtr) As Boolean
    End Function

    <DllImport("winspool.Drv", EntryPoint:="EndPagePrinter", SetLastError:=True, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function EndPagePrinter(hPrinter As IntPtr) As Boolean
    End Function

    <DllImport("winspool.Drv", EntryPoint:="WritePrinter", SetLastError:=True, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function WritePrinter(hPrinter As IntPtr, pBytes As IntPtr, dwCount As Integer, ByRef dwWritten As Integer) As Boolean
    End Function

    Public Shared Function SendStringToPrinter(szPrinterName As String, szString As String) As Boolean
        Dim pBytes As IntPtr
        Dim dwCount As Integer
        dwCount = szString.Length
        pBytes = Marshal.StringToCoTaskMemAnsi(szString)
        Dim hPrinter As IntPtr
        If OpenPrinter(szPrinterName, hPrinter, IntPtr.Zero) Then
            Dim di As New DOCINFOA()
            di.pDocName = "HTML Document"
            di.pDataType = "RAW"
            If StartDocPrinter(hPrinter, 1, di) Then
                If StartPagePrinter(hPrinter) Then
                    Dim dwWritten As Integer
                    WritePrinter(hPrinter, pBytes, dwCount, dwWritten)
                    EndPagePrinter(hPrinter)
                End If
                EndDocPrinter(hPrinter)
            End If
            ClosePrinter(hPrinter)
            Marshal.FreeCoTaskMem(pBytes)
            Return True
        End If
        Return False
    End Function
End Class

Class Program
    Shared Sub Main()
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        ' RawPrint cannot directly convert HTML to PDF
        ' It sends raw data to printer, no PDF generation capability
        RawPrinterHelper.SendStringToPrinter("Microsoft Print to PDF", html)
    End Sub
End Class

Imports System
Imports System.Drawing
Imports System.Drawing.Printing
Imports System.Runtime.InteropServices
Imports System.Text

Class RawPrinterHelper
    <StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Ansi)>
    Public Class DOCINFOA
        <MarshalAs(UnmanagedType.LPStr)> Public pDocName As String
        <MarshalAs(UnmanagedType.LPStr)> Public pOutputFile As String
        <MarshalAs(UnmanagedType.LPStr)> Public pDataType As String
    End Class

    <DllImport("winspool.Drv", EntryPoint:="OpenPrinterA", SetLastError:=True, CharSet:=CharSet.Ansi, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function OpenPrinter(<MarshalAs(UnmanagedType.LPStr)> szPrinter As String, ByRef hPrinter As IntPtr, pd As IntPtr) As Boolean
    End Function

    <DllImport("winspool.Drv", EntryPoint:="ClosePrinter", SetLastError:=True, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function ClosePrinter(hPrinter As IntPtr) As Boolean
    End Function

    <DllImport("winspool.Drv", EntryPoint:="StartDocPrinterA", SetLastError:=True, CharSet:=CharSet.Ansi, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function StartDocPrinter(hPrinter As IntPtr, level As Integer, <[In], MarshalAs(UnmanagedType.LPStruct)> di As DOCINFOA) As Boolean
    End Function

    <DllImport("winspool.Drv", EntryPoint:="EndDocPrinter", SetLastError:=True, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function EndDocPrinter(hPrinter As IntPtr) As Boolean
    End Function

    <DllImport("winspool.Drv", EntryPoint:="StartPagePrinter", SetLastError:=True, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function StartPagePrinter(hPrinter As IntPtr) As Boolean
    End Function

    <DllImport("winspool.Drv", EntryPoint:="EndPagePrinter", SetLastError:=True, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function EndPagePrinter(hPrinter As IntPtr) As Boolean
    End Function

    <DllImport("winspool.Drv", EntryPoint:="WritePrinter", SetLastError:=True, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)>
    Public Shared Function WritePrinter(hPrinter As IntPtr, pBytes As IntPtr, dwCount As Integer, ByRef dwWritten As Integer) As Boolean
    End Function

    Public Shared Function SendStringToPrinter(szPrinterName As String, szString As String) As Boolean
        Dim pBytes As IntPtr
        Dim dwCount As Integer
        dwCount = szString.Length
        pBytes = Marshal.StringToCoTaskMemAnsi(szString)
        Dim hPrinter As IntPtr
        If OpenPrinter(szPrinterName, hPrinter, IntPtr.Zero) Then
            Dim di As New DOCINFOA()
            di.pDocName = "HTML Document"
            di.pDataType = "RAW"
            If StartDocPrinter(hPrinter, 1, di) Then
                If StartPagePrinter(hPrinter) Then
                    Dim dwWritten As Integer
                    WritePrinter(hPrinter, pBytes, dwCount, dwWritten)
                    EndPagePrinter(hPrinter)
                End If
                EndDocPrinter(hPrinter)
            End If
            ClosePrinter(hPrinter)
            Marshal.FreeCoTaskMem(pBytes)
            Return True
        End If
        Return False
    End Function
End Class

Class Program
    Shared Sub Main()
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        ' RawPrint cannot directly convert HTML to PDF
        ' It sends raw data to printer, no PDF generation capability
        RawPrinterHelper.SendStringToPrinter("Microsoft Print to PDF", html)
    End Sub
End Class

Dieser Code demonstriert die Einschränkung von RawPrint .NET: Es sendet den rohen HTML-String an den Drucker, anstatt ihn als formatiertes Dokument zu rendern. Die Ausgabe wäre der wörtliche HTML-Markup-Text, keine gerenderte Webseite.

IronPDF HTML-Konvertierung

IronPDF bietet eine echte HTML-zu-PDF-Konvertierung mit vollständigem Rendering:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

IronPDF verwendet die Methode RenderHtmlAsPdf, um HTML-Inhalte in ein korrekt gerendertes PDF-Dokument zu konvertieren. Die Chromium-Engine verarbeitet CSS, JavaScript und HTML, um eine Ausgabe zu erzeugen, die dem Browser-Rendering entspricht.

URL zu PDF Konvertierung

Die Konvertierung von Live-Webseiten in PDF verdeutlicht den Leistungsunterschied.

RawPrint .NETURL-Behandlung

RawPrint .NET kann keine Webseiten rendern - es kann nur Rohdaten übertragen:

// NuGet: Install-Package System.Drawing.Common
using System;
using System.Net;
using System.Runtime.InteropServices;
using System.Text;

class Program
{
    static void Main()
    {
        // RawPrint cannot render web pages - only sends raw text/data
        // This would just print HTML source code, not rendered content
        using (WebClient client = new WebClient())
        {
            string htmlSource = client.DownloadString("https://example.com");
            // This prints raw HTML, not a rendered PDF
            RawPrinterHelper.SendStringToPrinter("Microsoft Print to PDF", htmlSource);
            Console.WriteLine("Raw HTML sent to printer (not rendered)");
        }
    }
}

// NuGet: Install-Package System.Drawing.Common
using System;
using System.Net;
using System.Runtime.InteropServices;
using System.Text;

class Program
{
    static void Main()
    {
        // RawPrint cannot render web pages - only sends raw text/data
        // This would just print HTML source code, not rendered content
        using (WebClient client = new WebClient())
        {
            string htmlSource = client.DownloadString("https://example.com");
            // This prints raw HTML, not a rendered PDF
            RawPrinterHelper.SendStringToPrinter("Microsoft Print to PDF", htmlSource);
            Console.WriteLine("Raw HTML sent to printer (not rendered)");
        }
    }
}

Imports System
Imports System.Net
Imports System.Runtime.InteropServices
Imports System.Text

Module Program
    Sub Main()
        ' RawPrint cannot render web pages - only sends raw text/data
        ' This would just print HTML source code, not rendered content
        Using client As New WebClient()
            Dim htmlSource As String = client.DownloadString("https://example.com")
            ' This prints raw HTML, not a rendered PDF
            RawPrinterHelper.SendStringToPrinter("Microsoft Print to PDF", htmlSource)
            Console.WriteLine("Raw HTML sent to printer (not rendered)")
        End Using
    End Sub
End Module

Imports System
Imports System.Net
Imports System.Runtime.InteropServices
Imports System.Text

Module Program
    Sub Main()
        ' RawPrint cannot render web pages - only sends raw text/data
        ' This would just print HTML source code, not rendered content
        Using client As New WebClient()
            Dim htmlSource As String = client.DownloadString("https://example.com")
            ' This prints raw HTML, not a rendered PDF
            RawPrinterHelper.SendStringToPrinter("Microsoft Print to PDF", htmlSource)
            Console.WriteLine("Raw HTML sent to printer (not rendered)")
        End Using
    End Sub
End Module

Bei diesem Ansatz wird der HTML-Quellcode heruntergeladen und als Rohtext an den Drucker gesendet. Das Ergebnis ist gedrucktes HTML-Markup, keine gerenderte Webseite mit Styling, Bildern oder Layout.

IronPDF URL-Konvertierung

IronPDF rendert Live-Websites direkt in PDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        // Render a live website directly to PDF with full CSS, JavaScript, and images
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("Website rendered to PDF successfully");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        // Render a live website directly to PDF with full CSS, JavaScript, and images
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("Website rendered to PDF successfully");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        ' Render a live website directly to PDF with full CSS, JavaScript, and images
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("Website rendered to PDF successfully")
    End Sub
End Class

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        ' Render a live website directly to PDF with full CSS, JavaScript, and images
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("Website rendered to PDF successfully")
    End Sub
End Class

Die Methode RenderUrlAsPdf navigiert zu der URL, führt JavaScript aus, wendet CSS-Styling an, lädt Bilder und erfasst die vollständig gerenderte Seite als PDF-Dokument.

Vergleich der Dokumentenformatierung

Die Formatierungsmöglichkeiten machen die architektonischen Unterschiede zwischen den beiden Ansätzen deutlich.

RawPrint .NETFormatierung

RawPrint .NET erfordert manuelle PCL- oder PostScript-Befehle für jegliche Formatierung:

// NuGet: Install-Package System.Drawing.Common
using System;
using System.Drawing.Printing;
using System.Runtime.InteropServices;
using System.Text;

class Program
{
    static void Main()
    {
        // RawPrint requires manual PCL/PostScript commands for formatting
        string pclCommands = "\x1B&l0O\x1B(s0p16.66h8.5v0s0b3T";
        string text = "Plain text document - limited formatting";
        byte[] data = Encoding.ASCII.GetBytes(pclCommands + text);
        RawPrinterHelper.SendBytesToPrinter("HP LaserJet", data);
    }
}

// NuGet: Install-Package System.Drawing.Common
using System;
using System.Drawing.Printing;
using System.Runtime.InteropServices;
using System.Text;

class Program
{
    static void Main()
    {
        // RawPrint requires manual PCL/PostScript commands for formatting
        string pclCommands = "\x1B&l0O\x1B(s0p16.66h8.5v0s0b3T";
        string text = "Plain text document - limited formatting";
        byte[] data = Encoding.ASCII.GetBytes(pclCommands + text);
        RawPrinterHelper.SendBytesToPrinter("HP LaserJet", data);
    }
}

Imports System
Imports System.Drawing.Printing
Imports System.Runtime.InteropServices
Imports System.Text

Module Program
    Sub Main()
        ' RawPrint requires manual PCL/PostScript commands for formatting
        Dim pclCommands As String = ChrW(&H1B) & "&l0O" & ChrW(&H1B) & "(s0p16.66h8.5v0s0b3T"
        Dim text As String = "Plain text document - limited formatting"
        Dim data As Byte() = Encoding.ASCII.GetBytes(pclCommands & text)
        RawPrinterHelper.SendBytesToPrinter("HP LaserJet", data)
    End Sub
End Module

Imports System
Imports System.Drawing.Printing
Imports System.Runtime.InteropServices
Imports System.Text

Module Program
    Sub Main()
        ' RawPrint requires manual PCL/PostScript commands for formatting
        Dim pclCommands As String = ChrW(&H1B) & "&l0O" & ChrW(&H1B) & "(s0p16.66h8.5v0s0b3T"
        Dim text As String = "Plain text document - limited formatting"
        Dim data As Byte() = Encoding.ASCII.GetBytes(pclCommands & text)
        RawPrinterHelper.SendBytesToPrinter("HP LaserJet", data)
    End Sub
End Module

Die Escape-Sequenzen (\x1B&l0O\x1B(s0p16.66h8.5v0s0b3T) stellen PCL-Befehle für die Druckerkonfiguration dar. Die Entwickler müssen druckerspezifische Befehlssprachen verstehen und Formatierungsanweisungen manuell erstellen.

IronPDF-Formatierung

IronPDF verwendet Standard-HTML und CSS für eine umfassende Formatierung:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial; margin: 40px; }
                    h1 { color: #2c3e50; font-size: 24px; }
                    p { line-height: 1.6; color: #34495e; }
                    .highlight { background-color: yellow; font-weight: bold; }
                </style>
            </head>
            <body>
                <h1>Formatted Document</h1>
                <p>This is a <span class='highlight'>beautifully formatted</span> document with CSS styling.</p>
                <p>Complex layouts, fonts, colors, and images are fully supported.</p>
            </body>
            </html>";
        
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("formatted.pdf");
        Console.WriteLine("Formatted PDF created successfully");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial; margin: 40px; }
                    h1 { color: #2c3e50; font-size: 24px; }
                    p { line-height: 1.6; color: #34495e; }
                    .highlight { background-color: yellow; font-weight: bold; }
                </style>
            </head>
            <body>
                <h1>Formatted Document</h1>
                <p>This is a <span class='highlight'>beautifully formatted</span> document with CSS styling.</p>
                <p>Complex layouts, fonts, colors, and images are fully supported.</p>
            </body>
            </html>";
        
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("formatted.pdf");
        Console.WriteLine("Formatted PDF created successfully");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "
            <html>
            <head>
                <style>
                    body { font-family: Arial; margin: 40px; }
                    h1 { color: #2c3e50; font-size: 24px; }
                    p { line-height: 1.6; color: #34495e; }
                    .highlight { background-color: yellow; font-weight: bold; }
                </style>
            </head>
            <body>
                <h1>Formatted Document</h1>
                <p>This is a <span class='highlight'>beautifully formatted</span> document with CSS styling.</p>
                <p>Complex layouts, fonts, colors, and images are fully supported.</p>
            </body>
            </html>"
        
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("formatted.pdf")
        Console.WriteLine("Formatted PDF created successfully")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "
            <html>
            <head>
                <style>
                    body { font-family: Arial; margin: 40px; }
                    h1 { color: #2c3e50; font-size: 24px; }
                    p { line-height: 1.6; color: #34495e; }
                    .highlight { background-color: yellow; font-weight: bold; }
                </style>
            </head>
            <body>
                <h1>Formatted Document</h1>
                <p>This is a <span class='highlight'>beautifully formatted</span> document with CSS styling.</p>
                <p>Complex layouts, fonts, colors, and images are fully supported.</p>
            </body>
            </html>"
        
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("formatted.pdf")
        Console.WriteLine("Formatted PDF created successfully")
    End Sub
End Module

IronPDF nutzt die vorhandenen Webentwicklungskenntnisse. Die Entwickler verwenden eine vertraute HTML- und CSS-Syntax und keine druckerspezifischen Befehlssprachen. Dieser Ansatz unterstützt komplexe Layouts, Schriftarten, Farben und Bilder durch Standard-Webtechnologien.

API-Mapping-Referenz

Teams, die eine Migration von RawPrint .NETzu IronPDF evaluieren, können sich auf diese Zuordnung von Operationen beziehen:

RawPrint .NET	IronPDF
`Printer.SendBytesToPrinter()`	`pdf.Print()`
`Printer.OpenPrinter()`	Nicht anwendbar
`Printer.ClosePrinter()`	Nicht anwendbar
`Printer.StartDocPrinter()`	Nicht anwendbar
`Printer.WritePrinter()`	Nicht anwendbar
`Printer.EndDocPrinter()`	Nicht anwendbar
Nicht anwendbar	`ChromePdfRenderer`
Nicht anwendbar	`PdfDocument.Merge()`
Nicht anwendbar	`pdf.ApplyWatermark()`

Das Mapping zeigt, dass IronPDF die manuelle Verwaltung von Druckerhandles vollständig überflüssig macht. Vorgänge, die explizite Aufrufe zum Öffnen/Schließen/Starten/Beenden in RawPrint .NETerfordern, werden automatisch von IronPDFs High-Level-API gehandhabt.

Merkmalsvergleichsmatrix

Feature	RawPrint .NET	IronPDF
PDF-Erstellung
HTML zu PDF	Nein	Ja
URL zu PDF	Nein	Ja
Von Grund auf neu erstellen	Nein	Ja
PDF-Bearbeitung
PDFs zusammenführen	Nein	Ja
PDFs teilen	Nein	Ja
Wasserzeichen hinzufügen	Nein	Ja
Vorhandenes bearbeiten	Nein	Ja
Drucken
PDF ausdrucken	Ja (roh)	Ja (hochsprachlich)
Dialog drucken	Nein	Ja
Mehrere Exemplare	Beschränkt	Ja
DPI-Steuerung	Nein	Ja
Duplex	Nein	Ja
Plattform
Windows	Ja	Ja
Linux	Nein	Ja
macOS	Nein	Ja
Docker	Nein	Ja
Anderes
Sicherheit	Nein	Ja
Digitale Signaturen	Nein	Ja
PDF/A	Nein	Ja

Vergleich Drucken

Für die eine Fähigkeit, die RawPrint .NETbietet - das Drucken vorhandener Dokumente - unterscheidet sich die Komplexität der API erheblich.

RawPrint .NETDrucken

using RawPrint;
using System.IO;

byte[] pdfBytes = File.ReadAllBytes("document.pdf");
bool success = Printer.SendBytesToPrinter(
    "Brother HL-L2340D",
    pdfBytes,
    pdfBytes.Length
);

if (!success)
{
    throw new Exception("Print failed");
}

using RawPrint;
using System.IO;

byte[] pdfBytes = File.ReadAllBytes("document.pdf");
bool success = Printer.SendBytesToPrinter(
    "Brother HL-L2340D",
    pdfBytes,
    pdfBytes.Length
);

if (!success)
{
    throw new Exception("Print failed");
}

Imports RawPrint
Imports System.IO

Dim pdfBytes As Byte() = File.ReadAllBytes("document.pdf")
Dim success As Boolean = Printer.SendBytesToPrinter("Brother HL-L2340D", pdfBytes, pdfBytes.Length)

If Not success Then
    Throw New Exception("Print failed")
End If

Imports RawPrint
Imports System.IO

Dim pdfBytes As Byte() = File.ReadAllBytes("document.pdf")
Dim success As Boolean = Printer.SendBytesToPrinter("Brother HL-L2340D", pdfBytes, pdfBytes.Length)

If Not success Then
    Throw New Exception("Print failed")
End If

RawPrint .NET erfordert das Lesen der Datei als Bytes und die manuelle Verwaltung von Erfolgs- und Fehlerzuständen.

IronPDF-Drucken

using IronPdf;

var pdf = PdfDocument.FromFile("document.pdf");

// Simple print
pdf.Print();

// Or specify printer
pdf.Print("Brother HL-L2340D");

using IronPdf;

var pdf = PdfDocument.FromFile("document.pdf");

// Simple print
pdf.Print();

// Or specify printer
pdf.Print("Brother HL-L2340D");

Imports IronPdf

Dim pdf = PdfDocument.FromFile("document.pdf")

' Simple print
pdf.Print()

' Or specify printer
pdf.Print("Brother HL-L2340D")

Imports IronPdf

Dim pdf = PdfDocument.FromFile("document.pdf")

' Simple print
pdf.Print()

' Or specify printer
pdf.Print("Brother HL-L2340D")

IronPDF bietet eine einfache Druckmethode, die die Druckerkommunikation automatisch abwickelt. Für fortgeschrittene Szenarien unterstützt IronPDF Druckoptionen wie Kopien, DPI- und Graustufeneinstellungen.

Wenn Teams eine RawPrint .NET-Migration in Betracht ziehen

Mehrere Faktoren veranlassen Entwicklungsteams, Alternativen zu RawPrint .NETzu prüfen:

Anforderungen an die PDF-Erzeugung werden zum Hindernis, wenn Anwendungen PDF-Dokumente erstellen müssen. RawPrint .NETkann keine PDF-Dateien erzeugen, sondern nur Bytes an Drucker übertragen. Teams, die HTML-zu-PDF-Konvertierung oder Dokumentenerstellung benötigen, müssen neben RawPrint .NETzusätzliche Bibliotheken verwenden.

Anforderungen für den plattformübergreifenden Einsatz übersteigen die Möglichkeiten von RawPrint .NET. Die Bibliothek verlässt sich vollständig auf das Windows-Drucksystem durch winspool.Drv-DLL-Importe. Linux-, macOS- und Docker-Einsätze erfordern unterschiedliche Lösungen.

API-Komplexität verursacht Wartungsaufwand. Die manuelle Verwaltung von Druckerhandles mit expliziten Sequenzen zum Öffnen/Schließen/Starten/Beenden erhöht die Komplexität des Codes und das Fehlerpotenzial im Vergleich zu High-Level-APIs.

Beschränkte Druckkontrolle wirkt sich auf die Produktionsanforderungen aus. RawPrint .NETbietet grundlegende Byte-Übertragung ohne Optionen für Kopien, DPI, Duplexdruck oder Druckdialoge.

Stärken und Gegensätze

RawPrint .NETStärken

Direkter Druckerzugriff für spezielle Hardware (Etikettendrucker, ZPL/EPL-Geräte)
Minimaler Overhead für die Übertragung von Rohbytes
Einfache Architektur für grundlegende Druckszenarien
Keine externen Abhängigkeiten außer Windows-DLLs

RawPrint .NETBeschränkungen

Keine Möglichkeit zur Erstellung oder Generierung von PDF-Dateien
Unterstützung nur für Windows-Plattformen
Manuelle Verwaltung der Druckergriffe erforderlich
Kein HTML- oder URL-Rendering
Begrenzte Formatierung (PCL/PostScript-Kenntnisse erforderlich)
Keine PDF-Manipulationsfunktionen

IronPDF Stärken

Vollständige PDF-Erstellung aus HTML, URLs und Code
Plattformübergreifende Unterstützung (Windows, Linux, macOS, Docker)
High-Level-API zur Beseitigung der manuellen Ressourcenverwaltung
Vollständige CSS- und JavaScript-Unterstützung durch Chromium-Rendering
PDF-Bearbeitung (Zusammenführen, Teilen, Bearbeiten, Wasserzeichen)
Digitale Signaturen und Sicherheitsmerkmale
Professionelle Unterstützung und Dokumentation

IronPDF Überlegungen

Kommerzielles Lizenzierungsmodell
Fußabdruck der Chromium-Rendering-Engine
Konzipiert für PDF-Workflows und nicht für den reinen Druckerzugriff

Abschluss

RawPrint .NET und IronPDF dienen grundlegend unterschiedlichen Zwecken bei der Verarbeitung von .NET-Dokumenten. RawPrint .NETbietet einen Low-Level-Zugriff für das Senden von Raw-Bytes an Drucker-Spooler - nützlich für spezielle Druckszenarien mit Etikettendruckern oder Geräten, die eine direkte Befehlsübertragung erfordern. Sie kann jedoch keine PDF-Dokumente erstellen, rendern oder manipulieren.

Für Anwendungen, die PDF-Generierung, HTML-zu-PDF-Konvertierung, Dokumentenmanipulation oder plattformübergreifendes Drucken erfordern, bietet IronPDF umfassende Funktionen, die RawPrint .NETeinfach nicht bieten kann. Die High-Level-API macht die manuelle Verwaltung von Druckerhandles überflüssig und bietet gleichzeitig Funktionen für das Zusammenführen, Aufteilen, die Sicherheit und digitale Signaturen.

Bei der Evaluierung der Migration von RawPrint .NETzu IronPDF sollten die Teams ihre spezifischen Anforderungen berücksichtigen. Wenn es in erster Linie um die Erstellung und Bearbeitung von PDF-Dokumenten und erst in zweiter Linie um den Druck geht, deckt IronPDF den gesamten Workflow ab. Für Teams, die .NET 10 und C# 14 im Jahr 2026 mit plattformübergreifenden Einsatzanforderungen anstreben, bietet die Architektur von IronPDF eine geeignetere Grundlage als der Windows-spezifische RawPrint .NET-Ansatz.

Für eine Anleitung zur Implementierung lesen Sie bitte die IronPDF-Dokumentation und die Tutorials zum Drucken, die die PDF-Erzeugung und Druckmuster for .NET-Anwendungen abdecken.

Hinweis:: RawPrint ist eine eingetragene Marke ihres jeweiligen Eigentümers. Diese Seite ist nicht mit RawPrint verbunden, wird nicht von RawPrint 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.