using System;

using System.Collections.Generic;

using System.IO;

using System.Runtime.InteropServices;

using System.Text;

namespace PrintLabel

{

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;

}

/// <summary>

/// 发送文件到打印机

/// </summary>

/// <param name="szPrinterName">打印机名称</param>

/// <param name="szFileName">文件</param>

/// <returns></returns>

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;

}

/// <summary>

/// 发送字符串到打印机

/// </summary>

/// <param name="szPrinterName">打印机名称</param>

/// <param name="szString">指令</param>

/// <returns></returns>

public static bool SendStringToPrinter1(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.

//Encoding.GetEncoding("GB2312").GetBytes(szString);

pBytes = Marshal.StringToCoTaskMemAnsi(szString);

// Send the converted ANSI string to the printer.

SendBytesToPrinter(szPrinterName, pBytes, dwCount);

Marshal.FreeCoTaskMem(pBytes);

return true;

}

/// <summary>

/// 打印标签带有中文字符的ZPL指令

/// </summary>

/// <param name="printerName">打印机名称</param>

/// <param name="szString">指令</param>

/// <returns></returns>

public static string SendStringToPrinter(string printerName, string szString)

{

byte[] bytes = Encoding.GetEncoding("GB2312").GetBytes(szString); //转换格式

IntPtr ptr = Marshal.AllocHGlobal(bytes.Length + 2);

try

{

Marshal.Copy(bytes, 0, ptr, bytes.Length);

SendBytesToPrinter(printerName, ptr, bytes.Length);

return "success";

}

catch (Exception ex)

{

return ex.Message;

}

finally

{

Marshal.FreeCoTaskMem(ptr);

}

}

/// <summary>

/// 网络打印

/// </summary>

/// <param name="ip"></param>

/// <param name="port"></param>

/// <param name="szString"></param>

/// <returns></returns>

public static string SendStringToNetPrinter(string ip, int port, string szString)

{

try

{

//打开连接

System.Net.Sockets.TcpClient client = new System.Net.Sockets.TcpClient();

client.Connect(ip, port);

//写入zpl命令

System.IO.StreamWriter writer = new System.IO.StreamWriter(client.GetStream());

writer.Write(szString);

writer.Flush();

//关闭连接

writer.Close();

client.Close();

return "success";

}

catch (Exception ex)

{

return ex.Message;

}

}

}

}