c# 小票打印

时间：2021-06-01 19:28:46

c# 在进行小票打印时大致有三种方法。

1. 使用水晶报表进行打印。可以参考：https://www.cnblogs.com/aitong/p/10717786.html

2. 在 PrintDocument 对象上进行绘图，然后使用其打印方法直接打印。

using CrystalDecisions.CrystalReports.Engine;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Drawing.Printing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace CrTest

{

    public partial class Form1 : Form

    {

        string title = "标题标题标题标题标题标题标题标题标题标题标题";

        public Form1()

        {

            InitializeComponent();

        }

        private void button1_Click(object sender, EventArgs e)

        {

            //打印预览

            PrintPreviewDialog ppd = new PrintPreviewDialog();

            PrintDocument pd = new PrintDocument();

            //设置边距

            Margins margin = new Margins(, , , );

            pd.DefaultPageSettings.Margins = margin;

            int height = ;

            if (title.Length > )

            {

                height = ;

            }

            //纸张设置默认

            PaperSize pageSize = new PaperSize("First custom size", (int)( *  / 25.4), height);//58mm   转绘图宽度

            pd.DefaultPageSettings.PaperSize = pageSize;

            //打印事件设置

            pd.PrintPage += new PrintPageEventHandler(pd_PrintPage);

            ppd.Document = pd;

            ppd.ShowDialog();

            //try

            //{

            //    pd.Print();

            //}

            //catch (Exception ex)

            //{

            //    MessageBox.Show(ex.Message, "打印出错", MessageBoxButtons.OK, MessageBoxIcon.Error);

            //    pd.PrintController.OnEndPrint(pd, new PrintEventArgs());

            //}

        }

        private void pd_PrintPage(object sender, PrintPageEventArgs e)

        {

            Font font = new Font("Arial", , System.Drawing.FontStyle.Regular);

            string text = title;

            int yLocation = e.MarginBounds.Y;

            int center = e.PageSettings.PaperSize.Width /  ;

            int heightStep = ;

            while (text.Length > )

            {

                string printStr;

                if (text.Length > )

                {

                    printStr = text.Substring(, );

                    text = text.Substring();

                }

                else

                {

                    printStr = text;

                    text = "";

                }

                SizeF size = e.Graphics.MeasureString(printStr, font);

                heightStep =Convert.ToInt32( size.Height * 1.3);

                e.Graphics.DrawString(printStr, font, System.Drawing.Brushes.Black, center - size.Width / , yLocation);

                yLocation += heightStep;

            }

        }

    }

}

3. 使用 ESC/POS 控制指令

注意 SendStringToPrinter 这个接口。

using System;

using System.Collections.Generic;

using System.Drawing;

using System.IO;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

//https://www.cnblogs.com/QiuTianBaBa/p/6730829.html

//https://blog.csdn.net/andrewniu/article/details/80353655

namespace Evet2Basic.Model.Print.Report

{

    public class RawPrint

    {

        // 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.

        private static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, Int32 dwCount)

        {

            Int32 dwError = , dwWritten = ;

            IntPtr hPrinter = new IntPtr();

            DOCINFOA di = new DOCINFOA();

            bool bSuccess = false; // Assume failure unless you specifically succeed.

            di.pDocName = "XiaoPiao";

            di.pDataType = "RAW";

            // Open the printer.

            if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))

            {

                // Start a document.

                if (StartDocPrinter(hPrinter, , 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;

        }

        private 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();

            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, , 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 SendBytesToPrinter(string szPrinterName, byte[] buf)

        {

            bool bSuccess = false;

            // Your unmanaged pointer.

            IntPtr pUnmanagedBytes = new IntPtr();

            // Allocate some unmanaged memory for those bytes.

            pUnmanagedBytes = Marshal.AllocCoTaskMem(buf.Length);

            // Copy the managed byte array into the unmanaged array.

            Marshal.Copy(buf, , pUnmanagedBytes, buf.Length);

            // Send the unmanaged bytes to the printer.

            bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, buf.Length);

            // Free the unmanaged memory that you allocated earlier.

            Marshal.FreeCoTaskMem(pUnmanagedBytes);

            return bSuccess;

        }

        /// <summary>

        /// 切纸

        /// </summary>

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

        /// <returns></returns>

        public static bool Cut(string szPrinterName)

        {

            bool bSuccess = false;

            IntPtr pUnmanagedBytes = new IntPtr();

            byte[] data = new byte[] { 0x1B, 0x69 };

            pUnmanagedBytes = Marshal.AllocCoTaskMem(data.Length);

            Marshal.Copy(data, , pUnmanagedBytes, data.Length);

            bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, data.Length);

            Marshal.FreeCoTaskMem(pUnmanagedBytes);

            return true;

        }

        public static bool SendBytesToPrinterImg(string szPrinterName, Bitmap bmp, bool needWarning)

        {

            bool bSuccess = false;

            //Byte[] byte_send = Encoding.GetEncoding("GB2312").GetBytes("\x1b\x40");

            IntPtr pUnmanagedBytes = new IntPtr();

            //pUnmanagedBytes = Marshal.AllocCoTaskMem(byte_send.Length);

            //Marshal.Copy(byte_send, 0, pUnmanagedBytes, byte_send.Length);

            //bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, byte_send.Length);

            //Marshal.FreeCoTaskMem(pUnmanagedBytes);

            byte[] data = new byte[] { 0x1B, 0x33, 0x00 };

            //pUnmanagedBytes = new IntPtr(0);

            pUnmanagedBytes = Marshal.AllocCoTaskMem(data.Length);

            Marshal.Copy(data, , pUnmanagedBytes, data.Length);

            bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, data.Length);

            Marshal.FreeCoTaskMem(pUnmanagedBytes);

            data[] = (byte)'\x00';

            data[] = (byte)'\x00';

            data[] = (byte)'\x00';

            Color pixelColor;

            // ESC * m nL nH 点阵图

            byte[] escBmp = new byte[] { 0x1B, 0x2A, 0x00, 0x00, 0x00 };

            escBmp[] = (byte)'\x21';

            //nL, nH

            escBmp[] = (byte)(bmp.Width % );

            escBmp[] = (byte)(bmp.Width / );

            // data

            for (int i = ; i < (bmp.Height / ) + ; i++)

            {

                //pUnmanagedBytes = new IntPtr(0);

                pUnmanagedBytes = Marshal.AllocCoTaskMem(escBmp.Length);

                Marshal.Copy(escBmp, , pUnmanagedBytes, escBmp.Length);

                bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, escBmp.Length);

                Marshal.FreeCoTaskMem(pUnmanagedBytes);

                byte[] temptype = new byte[bmp.Width * ];

                int lengthNow = ;

                for (int j = ; j < bmp.Width; j++)

                {

                    for (int k = ; k < ; k++)

                    {

                        if (((i * ) + k) < bmp.Height)   // if within the BMP size

                        {

                            pixelColor = bmp.GetPixel(j, (i * ) + k);

                            if (pixelColor.R == )

                            {

                                data[k / ] += (byte)( >> (k % ));

                            }

                        }

                    }

                    data.CopyTo(temptype, lengthNow);

                    lengthNow += ;

                    data[] = (byte)'\x00';

                    data[] = (byte)'\x00';

                    data[] = (byte)'\x00';

                }

                //pUnmanagedBytes = new IntPtr(0);

                pUnmanagedBytes = Marshal.AllocCoTaskMem(temptype.Length);

                Marshal.Copy(temptype, , pUnmanagedBytes, temptype.Length);

                bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, temptype.Length);

                Marshal.FreeCoTaskMem(pUnmanagedBytes);

                System.Threading.Thread.Sleep();

            }

            byte[] dataClear = new byte[] { 0x1B, 0x40 };

            pUnmanagedBytes = Marshal.AllocCoTaskMem(dataClear.Length);

            Marshal.Copy(dataClear, , pUnmanagedBytes, dataClear.Length);

            bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, dataClear.Length);

            Marshal.FreeCoTaskMem(pUnmanagedBytes);

            return bSuccess;

        }

        public static bool SendStringToPrinter(string szPrinterName, string szString)

        {

            try

            {

                //指令见打印机官方文档    http://www.xprinter.net/index.php/Server/index/cid/3

                byte[] smallArray = new byte[] { , ,  };

                List<byte> list = new List<byte>();

                list.AddRange(smallArray);

                while (szString.Contains("<B>") || szString.Contains("<A>"))

                {

                    if (!szString.Contains("<B>"))

                    {

                        ReplaceAB(ref szString, ref list, );

                    }

                    else if (!szString.Contains("<A>"))

                    {

                        ReplaceAB(ref szString, ref list, );

                    }

                    else

                    {

                        int indexA = szString.IndexOf("<A>");

                        int indexB = szString.IndexOf("<B>");

                        if (indexA < indexB)

                        {

                            ReplaceAB(ref szString, ref list, );

                        }

                        else

                        {

                            ReplaceAB(ref szString, ref list, );

                        }

                    }

                }

                Encoding enc = Encoding.GetEncoding("gb2312");

                list.AddRange(enc.GetBytes(szString));

                return RawPrint.SendBytesToPrinter(szPrinterName, list.ToArray());

            }

            catch (Exception)

            {

                return false;

            }

        }

        private static void ReplaceAB(ref string szString, ref List<byte> list, int mul)

        {

            //指令见打印机官方文档    http://www.xprinter.net/index.php/Server/index/cid/3

            string replaceStr1 = "<B>";

            string replaceStr2 = "</B>";

            byte[] smallArray = new byte[] { , ,  };

            byte[] bigArray = new byte[] { , ,  };   //放大三倍    //29, 33字体放大指令  34放大倍数 ( 0一倍    17两倍   34三倍     51四倍    68五倍     85六倍)

            if (mul == )

            {

                replaceStr1 = "<A>";

                replaceStr2 = "</A>";

                bigArray = new byte[] { , ,  };   //放大两倍

            }

            Encoding enc = Encoding.GetEncoding("gb2312");

            int index = szString.IndexOf(replaceStr1);

            string first = szString.Substring(, index);

            list.AddRange(enc.GetBytes(first));//第一段

            list.AddRange(bigArray);//变成大写

            szString = szString.Substring(index + );

            int index2 = szString.IndexOf(replaceStr2);

            string second = szString.Substring(, index2);

            list.AddRange(enc.GetBytes(second));//大写段

            list.AddRange(smallArray);//变小写

            szString = szString.Substring(index2 + );

        }

    }

}

相关文章