PORóWNANIE

RawPrint .NET vs IronPDF: Przewodnik porównania technicznego

Zaktualizowano:

Kiedy programiści .NET oceniają rozwiązania do drukowania dokumentów i generowania plików PDF,RawPrint .NETiIronPDFoferują zasadniczo różne podejścia o odmiennych możliwościach.RawPrint .NETzapewnia dostęp niskopoziomowy do buforów wydruku w celu wysyłania surowych bajtów bezpośrednio do drukarek, natomiastIronPDFoferuje kompletny, wysokopoziomowy interfejs API do tworzenia, edycji i drukowania dokumentów PDF. W niniejszym porównaniu technicznym przeanalizowano oba rozwiązania pod kątem aspektów, które mają największe znaczenie dla profesjonalnych programistów i architektów podejmujących decyzje dotyczące przetwarzania dokumentów w aplikacjach .NET.

Zrozumienie RawPrint .NET

RawPrint .NET to niskopoziomowe narzędzie do drukowania, które wysyła surowe bajty bezpośrednio do buforów drukarek. Umożliwia to aplikacjom ominięcie konwencjonalnych sterowników drukarek i przesyłanie danych poleceń bezpośrednio do drukarek. Ta funkcja jest szczególnie przydatna w przypadku specjalistycznych drukarek, takich jak drukarki etykiet wykorzystujące języki ZPL (Zebra Programming Language) lub EPL (Eltron Programming Language).

Istotna różnica:RawPrint .NETnie jest biblioteką PDF. Nie tworzy, nie generuje, nie renderuje ani nie modyfikuje dokumentów PDF. Jego jedyną funkcją jest przesyłanie bajtów do sprzętu drukarki za pośrednictwem podsystemu PRINT systemu Windows.

Podejście wymaga od programistów pracy z importami DLL specyficznymi dlaWindowsz winspool.Drv, zarządzając uchwytami drukarki ręcznie poprzez serię wywołań funkcji: OpenPrinter, StartDocPrinter, StartPagePrinter, WritePrinter, EndPagePrinter, EndDocPrinter, oraz ClosePrinter.

ArchitekturaRawPrint .NETwymaga dogłębnego zrozumieniuiuiuiuia języków poleceń drukarek. W celu formatowania dokumentów programiści muszą tworzyć ręczne polecenia PCL (Printer Command Language) lub PostScript jako sekwencje escape osadzone w strumieniu bajtów.

Zrozumienie IronPDF

IronPDF zapewnia kompletny, wysokopoziomowy interfejs API do operacji na plikach PDF w aplikacjach .NET. Biblioteka zawiera silnik renderujący oparty na Chromium, który konwertuje HTML, CSS i JavaScript na dokumenty PDF z zachowaniem pełnej wierności. Oprócz generowania plików PDF,IronPDFoferuje funkcje manipulacji plikami PDF, w tym scałanie, dzielenie, edycję oraz funkcje bezpieczeństwa.

ArchitekturaIronPDFabstrahuje złożoność renderowania dokumentów i komunikacji z drukarką. Klasa ChromePdfRenderer obsługuje konwersję HTML na PDF, podczas gdy klasa PdfDocument zapewnia metody manipulacji i drukowania bez konieczności ręcznego zarządzania zasobami.

Luka w podstawowych kompetencjach

Podstawowa różnica międzyRawPrint .NETaIronPDFpolega na ich przeznaczeniu i możliwościach:

Zadanie RawPrint .NET IronPDF
Utwórz plik PDF z HTML Nieobsługiwane Tak
Utwórz plik PDF z adresu URL Nieobsługiwane Tak
Edytuj/modyfikuj pliki PDF Nieobsługiwane Tak
Łączenie/dzielenie plików PDF Nieobsługiwane Tak
PRINT istniejący plik PDF Tak (tylko surowe bajty) Tak (API wysokiego poziomu)
Kontrola drukowania Podstawowe Pełne opcje
Wielopłatformowe Tylko dla systemuWindows Tak

Z porównania tego wynika, żeRawPrint .NETiIronPDFsłużą do zupełnie różnych zastosowań.RawPrint .NETzajmuje się komunikacją z drukarkami na niskim poziomie, podczas gdyIronPDFzapewnia kompleksowe zarządzanie cyklem życia dokumentów PDF.

Konwersja HTML do PDF

Kontrast międzyRawPrint .NETaIronPDFstaje się wyraźny przy analizowaniu scenariuszy konwersji HTML do PDF.

RawPrint .NETObsługa HTML

RawPrint .NET nie może konwertować plików HTML do formatu PDF. Może wysyłać do drukarek wyłącznie surowe dane:

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

Ten kod pokazuje ograniczenie RawPrint .NET: wysyła on surowy ciąg HTML do drukarki zamiast renderować go jako sformatowany dokument. Wynikiem będzie dosłowny tekst znaczników HTML, a nie wyrenderowana strona internetowa.

Konwersja HTML w IronPDF

IronPDF zapewnia rzeczywistą konwersję HTML do PDF z pełnym renderowaniem:

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

PodejścieIronPDFwykorzystuje metodę RenderHtmlAsPdf do konwersji treści HTML na poprawnie wyrenderowany dokument PDF. Silnik Chromium przetwarza CSS, JavaScript i HTML, aby wygenerować wynik zgodny z renderowaniem przeglądarki.

Konwersja adresów URL do formatu PDF

Konwersja aktywnych stron internetowych do formatu PDF dodatkowo ilustruje różnicę w możliwościach.

Obsługa adresów URL w RawPrint .NET

RawPrint .NET nie może renderować stron internetowych — może jedynie przesyłać surowe dane:

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

To podejście polega na pobraniu kodu źródłowego HTML i wysłaniu go jako surowego tekstu do drukarki. Wynikiem jest wydrukowany kod HTML, a nie wyrenderowana strona internetowa ze stylami, obrazami lub układem.

Konwersja adresów URL w IronPDF

IronPDF renderuje aktywne strony internetowe bezpośrednio do formatu 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
$vbLabelText   $csharpLabel

Metoda RenderUrlAsPdf przechodzi do adresu URL, wykonuje kod JavaScript, stosuje stylizację CSS, ładuje obrazy i przechwytuje w pełni wyrenderowaną stronę jako dokument PDF.

Porównanie formatowania dokumentów

Możliwości formatowania ujawniają różnice architektoniczne między tymi dwoma podejściami.

RawPrint .NETFormatowanie

RawPrint .NET wymaga ręcznego wprowadzania poleceń PCL lub PostScript w celu sformatowania:

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

Sekwencje ucieczki (\x1B&l0O\x1B(s0p16.66h8.5v0s0b3T) reprezentują polecenia PCL dla konfiguracji drukarki. Programiści muszą rozumieć języki poleceń specyficzne dla drukarek i ręcznie tworzyć instrukcje formatowania.

Formatowanie IronPDF

IronPDF wykorzystuje standardowy HTML i CSS do bogatego formatowania:

// 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");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared 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 Class
$vbLabelText   $csharpLabel

IronPDF wykorzystuje istniejące umiejętności w zakresie tworzenia stron internetowych. Programiści używają znanej im składni HTML i CSS zamiast języków poleceń specyficznych dla drukarek. To podejście obsługuje złożone układy, czcionki, kolory i obrazy za pomocą standardowych technologii internetowych.

Przewodnik po mapowaniu API

Zespoły oceniające migracjęRawPrint .NETdoIronPDFmogą skorzystać z poniższego zestawienia operacji:

RawPrint .NET IronPDF
Printer.SendBytesToPrinter() pdf.Print()
Printer.OpenPrinter() Nie dotyczy
Printer.ClosePrinter() Nie dotyczy
Printer.StartDocPrinter() Nie dotyczy
Printer.WritePrinter() Nie dotyczy
Printer.EndDocPrinter() Nie dotyczy
Nie dotyczy ChromePdfRenderer
Nie dotyczy PdfDocument.Merge()
Nie dotyczy pdf.ApplyWatermark()

Schemat pokazuje, żeIronPDFcałkowicie eliminuje ręczne zarządzanie uchwytami drukarki. Operacje wymagające wyraźnych wywołań open/close/start/end wRawPrint .NETsą obsługiwane automatycznie przez API wysokiego poziomu IronPDF.

Tabela porównawcza funkcji

Funkcja RawPrint .NET IronPDF
Tworzenie plików PDF
HTML do PDF Nie Tak
URL do pliku PDF Nie Tak
Stwórz od podstaw Nie Tak
Manipulacja plikami PDF
Łączenie plików PDF Nie Tak
Podział plików PDF Nie Tak
Dodaj znaki wodne Nie Tak
Edytuj istniejący Nie Tak
Drukowanie
PRINT PDF Tak (surowy) Tak (ogólne)
Okno dialogowe drukowania Nie Tak
Wiele kopii Ograniczone Tak
Kontrola DPI Nie Tak
Duplex Nie Tak
Platforma
Windows Tak Tak
Linux Nie Tak
macOS Nie Tak
Docker Nie Tak
Inne
Bezpieczeństwo Nie Tak
Podpisy cyfrowe Nie Tak
PDF/A Nie Tak

Porównanie drukowania

W przypadku jedynej funkcji, jaką zapewniaRawPrint .NET— drukowania istniejących dokumentów — złożoność API znacznie się różni.

Drukowanie RawPrint .NET

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

RawPrint .NET wymaga odczytu pliku jako bajtów i ręcznego zarządzania stanami powodzenia/niepowodzenia.

Drukowanie w IronPDF

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

IronPDF udostępnia prostą metodę PRINT, która automatycznie obsługuje komunikację z drukarką. W zaawansowanych scenariuszachIronPDFobsługuje opcje drukowania, w tym ustawienia dotyczące kopii, rozdzielczości DPI i skali szarości.

Kiedy zespoły rozważają migrację do RawPrint .NET

Kilka czynników skłania zespoły programistów do rozważenia alternatyw dla RawPrint .NET:

Wymagania dotyczące generowania plików PDF stają się przeszkodą, gdy aplikacje muszą tworzyć dokumenty PDF.RawPrint .NETnie może generować plików PDF — przekazuje jedynie bajty do drukarek. Zespoły wymagające konwersji HTML do PDF lub tworzenia dokumentów muszą korzystać z dodatkowych bibliotek obok RawPrint .NET.

Wymagania dotyczące wdrażania na wielu platformach wykraczają poza możliwości RawPrint .NET. Biblioteka polega całkowicie na podsystemie drukowaniaWindowspoprzez importy DLL z winspool.Drv. Wdrożenia w systemach Linux,macOSiDockerwymagają różnych rozwiązań.

Złożoność API powoduje obciążenie związane z utrzymaniem. Ręczne zarządzanie uchwytami drukarki z wyraźnymi sekwencjami otwierania/zamykania/rozpoczynania/kończenia zwiększa złożoność kodu i ryzyko błędów w porównaniu z interfejsami API wysokiego poziomu.

Ograniczona kontrola nad wydrukiem wpływa na wymagania produkcyjne.RawPrint .NETzapewnia podstawową transmisję bajtów bez opcji kopiowania, DPI, drukowania dwustronnego ani okien dialogowych drukowania.

Zalety i kompromisy

Zalety RawPrint .NET

  • Bezpośredni dostęp do drukarek dla specjalistycznego sprzętu (drukarki etykiet, urządzenia ZPL/EPL)
  • Minimalne obciążenie związane z transmisją surowych bajtów
  • Prosta architektura dla podstawowych scenariuszy drukowania
  • Brak zewnętrznych zależności poza bibliotekami DLL systemu Windows

Ograniczenia RawPrint .NET

  • Brak możliwości tworzenia lub generowania plików PDF
  • Obsługa wyłącznie platformy Windows
  • Wymagane ręczne zarządzanie uchwytami drukarki
  • Bez renderowania HTML lub adresów URL
  • Ograniczone formatowanie (wymagańa znajomość PCL/PostScript)
  • Brak funkcji edycji plików PDF

Atuty IronPDF

  • Kompletne generowanie plików PDF na podstawie HTML, adresów URL i kodu
  • Obsługa wielu platform (Windows, Linux, macOS, Docker)
  • API wysokiego poziomu eliminujące ręczne zarządzanie zasobami
  • Pełna obsługa CSS i JavaScript dzięki renderowaniu Chromium
  • Manipulacja plikami PDF (łączenie, dzielenie, edycja, znak wodny)
  • Podpisy cyfrowe i funkcje bezpieczeństwa
  • Profesjonalne wsparcie i dokumentacja

Uwagi dotyczące IronPDF

  • Komercyjny model licencjonowania
  • Ślad silnika renderującego Chromium
  • Przeznaczony raczej do przepływów pracy z plikami PDF niż do bezpośredniego dostępu do drukarki

Wnioski

RawPrint .NET iIronPDFsłużą zasadniczo różnym celom w przetwarzaniu dokumentów w środowisku .NET.RawPrint .NETzapewnia dostęp niskopoziomowy do wysyłania surowych bajtów do buforów drukarek — przydatny w specjalistycznych scenariuszach drukowania z wykorzystaniem drukarek etykiet lub urządzeń wymagających bezpośredniej transmisji poleceń. Nie może jednak tworzyć, renderować ani modyfikować dokumentów PDF.

W przypadku aplikacji wymagających generowania plików PDF, konwersji HTML na PDF, manipulacji dokumentami lub drukowania międzyplatformowego,IronPDFzapewnia kompleksowe możliwości, którychRawPrint .NETpo prostu nie oferuje. API wysokiego poziomu eliminuje ręczne zarządzanie uchwytami drukarek, dodając jednocześnie funkcje scałania, dzielenia, zabezpieczeń i podpisów cyfrowych.

Oceniając migracjęRawPrint .NETdo IronPDF, zespoły powinny wziąć pod uwagę swoje konkretne wymagania. Jeśli głównym zadaniem jest tworzenie i edycja dokumentów PDF, a drukowanie jest funkcją dodatkową,IronPDFobsługuje cały proces. Dla zespołów, które w 2026 r. planują wdrożenie .NET 10 i C# 14 z wymaganiami dotyczącymi wdrożenia wielopłatformowego, architekturaIronPDFstanowi bardziej odpowiednią podstawę niż podejście RawPrint .NET, specyficzne dla systemu Windows.

Aby uzyskać wskazówki dotyczące wdrożenia, zapoznaj się z dokumentacją IronPDF oraz samouczkami dotyczącymi drukowania, obejmującymi generowanie plików PDF i wzorce drukowania dla aplikacji .NET.