Wie Sie Rohdaten an einen Drucker senden, mithilfe von Visual c# .NET

SPRACHE AUSWÄHLEN SPRACHE AUSWÄHLEN
Artikel-ID: 322091 - Produkte anzeigen, auf die sich dieser Artikel bezieht
Alles erweitern | Alles schließen

Auf dieser Seite

Zusammenfassung

In diesem Artikel wird die Win32-Spooler-Funktionen aus einem Programm verwenden, die Sie erstellen mithilfe von Visual c# .NET veranschaulicht.

Weitere Informationen

Um Rohdaten an einen Drucker aus dem Microsoft .NET Framework zu senden, muss Ihr Programm mit Win32-Spooler Funktionen arbeiten. Über .NET Framework können Sie mithilfe von PrintDocument , PrintController und zugeordneten Klassen drucken. Jedoch mit dem .NET Framework kann nicht vorformatierte Drucker-Ready-Daten an einen Drucker senden.

Möglicherweise müssen Sie unformatierte Daten an einen Drucker für folgende Aufgaben zu senden:
  • Escape-Sequenzen zu senden.
  • Downloaden Sie und verwenden Sie ladbare Schriftarten.
  • Vorgedruckte Spool-Dateien.
Um solche und andere Arten von unformatierten Daten an einen Drucker senden, muss Ihr Code mit Win32-Spooler Application Programmer Interfaces (APIs) arbeiten. Der folgende Code veranschaulicht den Inhalt einer vorformatierten Datei in den Arbeitsspeicher lesen, und senden diese Bytes an den Drucker mit Hilfe von WritePrinter .

Hinweis : Sie können dieser Ansatz nicht in derselben drucken Auftrag als eine systemeigene PrintDocument drucken Auftrag verwenden. Sie müssen entweder das .NET Framework verwenden, zu drucken oder senden ihre eigenen drucken Auftrag Bytes.

Erstellen eines Projekts, das vorformatierte Daten druckt

  1. Starten Sie Visual Studio .NET. Im Menü Datei klicken Sie auf neu und klicken Sie dann auf Projekt . Klicken Sie unter Projekttypen auf den Ordner Visual C#-Projekte . Klicken Sie auf der Liste Vorlagen auf Windows-Anwendung und klicken Sie dann auf OK . Standardmäßig wird jetzt Form1 erstellt.
  2. Im Menü Ansicht klicken Sie auf Toolbox , um die Toolbox anzuzeigen, und fügen Sie eine Schaltfläche zu Form1 hinzu. Diese Schaltfläche heißt Button1.
  3. Fügen Sie eine andere Schaltfläche zu Form1 hinzu. Diese Schaltfläche heißt Button2.
  4. Doppelklicken Sie auf Button1 . Das Codefenster für das Formular erscheint.
  5. Ersetzen Sie die Button1_Click -Unterroutine durch den folgenden Code:
    private void button1_Click(object sender, System.EventArgs e)
    {
        // Allow the user to select a file.
        OpenFileDialog ofd = new OpenFileDialog();
        if( DialogResult.OK == ofd.ShowDialog(this) )
        {
            // Allow the user to select a printer.
            PrintDialog pd  = new PrintDialog();
            pd.PrinterSettings = new PrinterSettings();
            if( DialogResult.OK == pd.ShowDialog(this) )
            {
                // Print the file to the printer.
                RawPrinterHelper.SendFileToPrinter(pd.PrinterSettings.PrinterName, ofd.FileName);
            }
        }
    }
    					
  6. Ersetzen Sie die Unterroutine Button2_Click durch den folgenden Code:
    private void button2_Click(object sender, System.EventArgs e)
    {
        string s = "Hello"; // device-dependent string, need a FormFeed?
        
        // Allow the user to select a printer.
        PrintDialog pd  = new PrintDialog();
        pd.PrinterSettings = new PrinterSettings();
        if( DialogResult.OK == pd.ShowDialog(this) )
        {
            // Send a printer-specific to the printer.
            RawPrinterHelper.SendStringToPrinter(pd.PrinterSettings.PrinterName, s);
        }
    }
    					
  7. Fügen Sie den folgenden Code am Anfang der Datei:
    using System;
    using System.Drawing;
    using System.Drawing.Printing;
    using System.Windows.Forms;
    using System.Runtime.InteropServices;
    					
  8. Fügen Sie in der Hauptanwendung Namespace aber außerhalb Klassendefinitionen folgenden Code hinzu:
    public class RawPrinterHelper
    {
        // Structure and API declarions:
        [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 );
    
        // SendBytesToPrinter()
        // When the function is given a printer name and an unmanaged array
        // of bytes, the function sends those bytes to the print queue.
        // Returns true on success, false on failure.
        public static bool SendBytesToPrinter( string szPrinterName, IntPtr pBytes, Int32 dwCount)
        {
            Int32    dwError = 0, dwWritten = 0;
            IntPtr    hPrinter = new IntPtr(0);
            DOCINFOA    di = new DOCINFOA();
            bool    bSuccess = false; // Assume failure unless you specifically succeed.
    
            di.pDocName = "My C#.NET RAW Document";
            di.pDataType = "RAW";
    
            // Open the printer.
            if( OpenPrinter( szPrinterName.Normalize(), out hPrinter, IntPtr.Zero ) )
            {
                // Start a document.
                if( StartDocPrinter(hPrinter, 1, di) )
                {
                    // Start a page.
                    if( StartPagePrinter(hPrinter) )
                    {
                        // Write your bytes.
                        bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                        EndPagePrinter(hPrinter);
                    }
                    EndDocPrinter(hPrinter);
                }
                ClosePrinter(hPrinter);
            }
            // If you did not succeed, GetLastError may give more information
            // about why not.
            if( bSuccess == false )
            {
                    dwError = Marshal.GetLastWin32Error();
            }
            return bSuccess;
        }
    
        public static bool SendFileToPrinter( string szPrinterName, string szFileName )
        {
            // Open the file.
            FileStream fs = new FileStream(szFileName, FileMode.Open);
            // Create a BinaryReader on the file.
            BinaryReader br = new BinaryReader(fs);
            // Dim an array of bytes big enough to hold the file's contents.
            Byte []bytes = new Byte[fs.Length];
            bool bSuccess = false;
            // Your unmanaged pointer.
            IntPtr pUnmanagedBytes = new IntPtr(0);
            int nLength;
    
            nLength = Convert.ToInt32(fs.Length);
            // Read the contents of the file into the array.
            bytes = br.ReadBytes( nLength );
            // Allocate some unmanaged memory for those bytes.
            pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength);
            // Copy the managed byte array into the unmanaged array.
            Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength);
            // Send the unmanaged bytes to the printer.
            bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, nLength);
            // Free the unmanaged memory that you allocated earlier.
            Marshal.FreeCoTaskMem(pUnmanagedBytes);
            return bSuccess;
        }
        public static bool SendStringToPrinter( string szPrinterName, string szString )
        {
            IntPtr pBytes;
            Int32 dwCount;
            // How many characters are in the string?
            dwCount = szString.Length;
            // Assume that the printer is expecting ANSI text, and then convert
            // the string to ANSI text.
            pBytes = Marshal.StringToCoTaskMemAnsi(szString);
            // Send the converted ANSI string to the printer.
            SendBytesToPrinter(szPrinterName, pBytes, dwCount);
            Marshal.FreeCoTaskMem(pBytes);
            return true;
        }
    }
    					
  9. Drücken Sie die Taste [F5], um das Programm erstellen und dann ausführen zu lassen.
  10. Klicken Sie auf Button1 zu laden und Inhalt einer Datei zu drucken.
  11. Klicken Sie auf Button2 , um eine Zeichenfolge zu drucken. (Möglicherweise müssen die Seite manuell ausgeworfen werden, da die Zeichenfolge ohne Formfeed -Befehl gesendet wird.)

Informationsquellen

Weitere Informationen finden Sie in den folgenden Artikeln der Microsoft Knowledge Base:
138594Wie Sie unformatierte Daten an einen Drucker senden, mithilfe der Win32-API

Eigenschaften

Artikel-ID: 322091 - Geändert am: Dienstag, 9. Mai 2006 - Version: 5.0
Die Informationen in diesem Artikel beziehen sich auf:
  • Microsoft .NET Framework Software Development Kit 1.0 Service Pack 2
  • Microsoft Windows XP Professional
  • the operating system: Microsoft Windows XP 64-Bit Edition
Keywords: 
kbmt kbdswgdi2003swept kbhowtomaster KB322091 KbMtde
Maschinell übersetzter Artikel
Wichtig: Dieser Artikel wurde maschinell und nicht von einem Menschen übersetzt. Die Microsoft Knowledge Base ist sehr umfangreich und ihre Inhalte werden ständig ergänzt beziehungsweise überarbeitet. Um Ihnen dennoch alle Inhalte auf Deutsch anbieten zu können, werden viele Artikel nicht von Menschen, sondern von Übersetzungsprogrammen übersetzt, die kontinuierlich optimiert werden. Doch noch sind maschinell übersetzte Texte in der Regel nicht perfekt, insbesondere hinsichtlich Grammatik und des Einsatzes von Fremdwörtern sowie Fachbegriffen. Microsoft übernimmt keine Gewähr für die sprachliche Qualität oder die technische Richtigkeit der Übersetzungen und ist nicht für Probleme haftbar, die direkt oder indirekt durch Übersetzungsfehler oder die Verwendung der übersetzten Inhalte durch Kunden entstehen könnten.
Den englischen Originalartikel können Sie über folgenden Link abrufen: 322091
Microsoft stellt Ihnen die in der Knowledge Base angebotenen Artikel und Informationen als Service-Leistung zur Verfügung. Microsoft übernimmt keinerlei Gewährleistung dafür, dass die angebotenen Artikel und Informationen auch in Ihrer Einsatzumgebung die erwünschten Ergebnisse erzielen. Die Entscheidung darüber, ob und in welcher Form Sie die angebotenen Artikel und Informationen nutzen, liegt daher allein bei Ihnen. Mit Ausnahme der gesetzlichen Haftung für Vorsatz ist jede Haftung von Microsoft im Zusammenhang mit Ihrer Nutzung dieser Artikel oder Informationen ausgeschlossen.

Ihr Feedback an uns

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com