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

Este artigo passo a passo mostra como usar funções de spooler de Win32 de um programa que você cria usando Visual C# .NET.

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 de impressora-pronto pré-formatados para uma impressora.

Talvez seja necessário que enviar dados não processados para uma impressora para fazer o seguinte:

• Envie seqüências de escape.
• Fazer o download e use fontes de disco.
• Spool arquivos pré-impressos.

Para enviar esses tipos e outros tipos de dados não processados para uma impressora, seu código deve trabalhar com interfaces do programador de aplicativos do Win32 spooler (APIs). O código a seguir mostra como ler o conteúdo de um arquivo de 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 nativo PrintDocument . Você deve usar o .NET Framework para imprimir ou enviar seus próprios bytes de trabalho de impressão.

Criar um projeto que imprime dados pré-formatados

1. Inicie o Visual Studio NET.. No menu Arquivo , clique em Novo e, em seguida, clique em Project . Em Project Types , clique na pasta de projetos do Visual C# . Na lista modelos , clique em Windows Application e, em seguida, clique em OK . Por padrão, o Form1 é criado.
2. No menu Exibir , clique em caixa de ferramentas para exibir a caixa de ferramentas e, em seguida, adicione um botão para Form1. Esse botão é chamado Button1.
3. Adicione outro botão para Form1. Esse 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:

   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. Substituir a sub-rotina Button2_Click com o seguinte código:

   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. Insira o código a seguir na parte superior do arquivo:

   using System;
   using System.Drawing;
   using System.Drawing.Printing;
   using System.Windows.Forms;
   using System.Runtime.InteropServices;
   					

8. Adicione o seguinte código dentro do namespace do aplicativo principal, mas fora nenhuma definição de classe:

   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. 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 seja necessário que ejetar a página manualmente, porque a seqüência de caracteres é enviada sem o comando formfeed .)

Para obter mais informações, clique nos números abaixo para ler os artigos na Base de Dados de Conhecimento da Microsoft: