Como enviar dados não processados para uma impressora usando o Visual Basic .NET

Este artigo passo a passo mostra como usar Win32 spooler funções de um programa que você criar usando o Visual Basic. NET.

Obter mais informações

Para enviar dados não processados para uma impressora do Microsoft .NET Framework, o programa deve trabalhar com funções de spooler do Win32. Por meio do .NET Framework, você pode imprimir usando PrintDocument , PrintController e classes associadas. No entanto, com o .NET Framework, você não pode enviar dados prontas para a impressora pré-formatados para uma impressora.

Talvez você precise enviar dados não processados para uma impressora para fazer o seguinte:

• Envie seqüências de escape.
• Fazer o download e, em seguida, use fontes de disco.
• Arquivos de spool pré-impresso.

Para enviar esses tipos e outros tipos de dados não processados para uma impressora, seu código deve funcionar com interfaces de programador do Win32 Spooler aplicativos (APIs). O código a seguir mostra como ler o conteúdo de um arquivo pré-formatado na memória e, em seguida, enviar esses bytes para a impressora usando WritePrinter .

Observação : Não É possível usar essa abordagem no trabalho de impressão mesmo como um trabalho de impressão PrintDocument nativo. Você deve usar o .NET Framework para imprimir ou enviar seu próprio trabalho de impressão bytes.

Criar um projeto que imprime dados pré-formatados

Para criar o projeto, execute essas etapas:

1. Inicie o Visual Studio NET.. No menu arquivo , clique em novo e, em seguida, clique em Project . Em Project Types , clique na pasta Projetos do Visual Basic . Na lista modelos , clique em Windows Application e, em seguida, clique em OK . Por padrão, é criado o Form1.
2. No menu Exibir , clique em caixa de ferramentas para exibir a caixa de ferramentas e, em seguida, adicione um botão ao Form1. Este botão é denominado Button1.
3. Adicione outro botão ao Form1. Este botão é denominado Button2.
4. Clique duas vezes em Button1 . A janela de código para o formulário é exibida.
5. Substituir a sub-rotina Button1_Click com o seguinte código:

       ' Click event handler for a button - designed to show how to use the
       ' SendFileToPrinter and SendBytesToPrinter functions.
       Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
           ' Allow the user to select a file.
           Dim ofd As New OpenFileDialog()
           If ofd.ShowDialog(Me) Then
               ' Allow the user to select a printer.
               Dim pd As New PrintDialog()
               pd.PrinterSettings = New PrinterSettings()
               If (pd.ShowDialog() = DialogResult.OK) Then
                   ' Print the file to the printer.
                   RawPrinterHelper.SendFileToPrinter(pd.PrinterSettings.PrinterName, ofd.FileName)
               End If
           End If
       End Sub ' Button1_Click()
   					

6. Substituir a sub-rotina Button2_Click com o seguinte código:

       ' Click event handler for a button - designed to show how to use the
       ' SendBytesToPrinter function to send a string to the printer.
       Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
           Dim s As String
           Dim pd As New PrintDialog()
   
           ' You need a string to send.
           s = "Hello, this is a test"
           ' Open the printer dialog box, and then allow the user to select a printer.
           pd.PrinterSettings = New PrinterSettings()
           If (pd.ShowDialog() = DialogResult.OK) Then
               RawPrinterHelper.SendStringToPrinter(pd.PrinterSettings.PrinterName, s)
           End If
       End Sub ' Button2_Click()
   					

7. Insira o código a seguir na parte superior do arquivo:

   Imports System.IO
   Imports System.Drawing.Printing
   Imports System.Runtime.InteropServices
   					

8. Add the following code inside the main application namespace but outside any class definitions:

   Public Class RawPrinterHelper
       ' Structure and API declarions:
       <StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)> _
       Structure DOCINFOW
           <MarshalAs(UnmanagedType.LPWStr)> Public pDocName As String
           <MarshalAs(UnmanagedType.LPWStr)> Public pOutputFile As String
           <MarshalAs(UnmanagedType.LPWStr)> Public pDataType As String
       End Structure
   
       <DllImport("winspool.Drv", EntryPoint:="OpenPrinterW", _
          SetLastError:=True, CharSet:=CharSet.Unicode, _
          ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
       Public Shared Function OpenPrinter(ByVal src As String, ByRef hPrinter As IntPtr, ByVal pd As Long) As Boolean
       End Function
       <DllImport("winspool.Drv", EntryPoint:="ClosePrinter", _
          SetLastError:=True, CharSet:=CharSet.Unicode, _
          ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
       Public Shared Function ClosePrinter(ByVal hPrinter As IntPtr) As Boolean
       End Function
       <DllImport("winspool.Drv", EntryPoint:="StartDocPrinterW", _
          SetLastError:=True, CharSet:=CharSet.Unicode, _
          ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
       Public Shared Function StartDocPrinter(ByVal hPrinter As IntPtr, ByVal level As Int32, ByRef pDI As DOCINFOW) As Boolean
       End Function
       <DllImport("winspool.Drv", EntryPoint:="EndDocPrinter", _
          SetLastError:=True, CharSet:=CharSet.Unicode, _
          ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
       Public Shared Function EndDocPrinter(ByVal hPrinter As IntPtr) As Boolean
       End Function
       <DllImport("winspool.Drv", EntryPoint:="StartPagePrinter", _
          SetLastError:=True, CharSet:=CharSet.Unicode, _
          ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
       Public Shared Function StartPagePrinter(ByVal hPrinter As IntPtr) As Boolean
       End Function
       <DllImport("winspool.Drv", EntryPoint:="EndPagePrinter", _
          SetLastError:=True, CharSet:=CharSet.Unicode, _
          ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
       Public Shared Function EndPagePrinter(ByVal hPrinter As IntPtr) As Boolean
       End Function
       <DllImport("winspool.Drv", EntryPoint:="WritePrinter", _
          SetLastError:=True, CharSet:=CharSet.Unicode, _
          ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
       Public Shared Function WritePrinter(ByVal hPrinter As IntPtr, ByVal pBytes As IntPtr, ByVal dwCount As Int32, ByRef dwWritten As Int32) As Boolean
       End Function
   
       ' 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 or False on failure.
       Public Shared Function SendBytesToPrinter(ByVal szPrinterName As String, ByVal pBytes As IntPtr, ByVal dwCount As Int32) As Boolean
           Dim hPrinter As IntPtr      ' The printer handle.
           Dim dwError As Int32        ' Last error - in case there was trouble.
           Dim di As DOCINFOW          ' Describes your document (name, port, data type).
           Dim dwWritten As Int32      ' The number of bytes written by WritePrinter().
           Dim bSuccess As Boolean     ' Your success code.
   
           ' Set up the DOCINFO structure.
           With di
               .pDocName = "My Visual Basic .NET RAW Document"
               .pDataType = "RAW"
           End With
           ' Assume failure unless you specifically succeed.
           bSuccess = False
           If OpenPrinter(szPrinterName, hPrinter, 0) Then
               If StartDocPrinter(hPrinter, 1, di) Then
                   If StartPagePrinter(hPrinter) Then
                       ' Write your printer-specific bytes to the printer.
                       bSuccess = WritePrinter(hPrinter, pBytes, dwCount, dwWritten)
                       EndPagePrinter(hPrinter)
                   End If
                   EndDocPrinter(hPrinter)
               End If
               ClosePrinter(hPrinter)
           End If
           ' If you did not succeed, GetLastError may give more information
           ' about why not.
           If bSuccess = False Then
               dwError = Marshal.GetLastWin32Error()
           End If
           Return bSuccess
       End Function ' SendBytesToPrinter()
   
       ' SendFileToPrinter()
       ' When the function is given a file name and a printer name, 
       ' the function reads the contents of the file and sends the
       ' contents to the printer.
       ' Presumes that the file contains printer-ready data.
       ' Shows how to use the SendBytesToPrinter function.
       ' Returns True on success or False on failure.
       Public Shared Function SendFileToPrinter(ByVal szPrinterName As String, ByVal szFileName As String) As Boolean
           ' Open the file.
           Dim fs As New FileStream(szFileName, FileMode.Open)
           ' Create a BinaryReader on the file.
           Dim br As New BinaryReader(fs)
           ' Dim an array of bytes large enough to hold the file's contents.
           Dim bytes(fs.Length) As Byte
           Dim bSuccess As Boolean
           ' Your unmanaged pointer.
           Dim pUnmanagedBytes As IntPtr
   
           ' Read the contents of the file into the array.
           bytes = br.ReadBytes(fs.Length)
           ' Allocate some unmanaged memory for those bytes.
           pUnmanagedBytes = Marshal.AllocCoTaskMem(fs.Length)
           ' Copy the managed byte array into the unmanaged array.
           Marshal.Copy(bytes, 0, pUnmanagedBytes, fs.Length)
           ' Send the unmanaged bytes to the printer.
           bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, fs.Length)
           ' Free the unmanaged memory that you allocated earlier.
           Marshal.FreeCoTaskMem(pUnmanagedBytes)
           Return bSuccess
       End Function ' SendFileToPrinter()
   
       ' When the function is given a string and a printer name,
       ' the function sends the string to the printer as raw bytes.
       Public Shared Function SendStringToPrinter(ByVal szPrinterName As String, ByVal szString As String)
           Dim pBytes As IntPtr
           Dim dwCount As Int32
           ' 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)
       End Function
   End Class
   					

9. Pressione F5 para criar e executar o programa.
10. Clique em Button1 para carregar e imprimir o conteúdo do arquivo.
11. Clique em Button2 para imprimir uma seqüência de caracteres. (Talvez você precise ejetar a página manualmente, porque a seqüência de caracteres será enviada sem o comando formfeed .)

Para obter mais informações, clique no número abaixo para ler o artigo na Base de dados de Conhecimento da Microsoft: