C#(.Net) 配合WQL实现并口读写

 

最近做开发，要对POS打印机就进行编程，说白了，也就是一个端口读写，再根据打印机说明实现几个POS指令就OK了，但是遇到了一个困难的问题，因为是无人系统，一个打印机打印客户单据，一个打印历史单据，这个还不是最要命的，最要命的是一个是串口的，一个是并口的，对于串口还好办，因为.Net里有现成的SerialPort类，可是并口就难了。

搜了一下网上的资料，不外乎两种方法。

第一种是用win32 API来实现。见

http://support.microsoft.com/kb/823179/zh-cn

另一种方式是用第三方的动态连接库inpout32.dll

http://www.codeproject.com/KB/vb/Inpout32_read.aspx

两种方式，各有优劣。

如果用win32 API的话，操作固然方便，但是有一个死穴，就是无法读并口的数据。

如果用inpout32呢，到是能读能写，但是并口的地址（0x378,0x379,0x37a）并不是一个固定值。

参见文档

http://www.cnblogs.com/thunderdanky/articles/795010.html

但是客户要求能实时检测打印机状态 。。 这个问题可是难住了一天。

怎么办?让客户自己到设备管理器里去找并口基址？MS有点太土了。

后来看了一些资料，突然发现WQL好像可以实现查找串口基址的功能，实验了一下，还真实现了，嘿嘿

好了，现在就贴代码

  1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4using System.Runtime.InteropServices;
  5using System.Management;
  6
  7namespace SFTech.POSPrint
  8{
  9    /**//// <summary>
 10    /// 串口类，IPort是抽像的端口类
 11    /// </summary>
 12    public class ParallelPort : IPort ,IDisposable
 13    {
 14
 15        inpout32相关#region inpout32相关
 16        [DllImport("inpout32.dll", EntryPoint = "Out32")]
 17        public static extern void Output(uint adress, int value);
 18
 19        [DllImport("inpout32.dll", EntryPoint = "Inp32")]
 20        public static extern int Input(uint adress); 
 21        [StructLayout(LayoutKind.Sequential)]
 22        private struct OVERLAPPED
 23        {
 24            int Internal;
 25            int InternalHigh;
 26            int Offset;
 27            int OffSetHigh;
 28            int hEvent;
 29        }
 30        #endregion
 31
 32        win32 API#region win32 API
 33        [DllImport("kernel32.dll ")]
 34        private static extern int CreateFile(
 35          string lpFileName,
 36          uint dwDesiredAccess,
 37          int dwShareMode,
 38          int lpSecurityAttributes,
 39          int dwCreationDisposition,
 40          int dwFlagsAndAttributes,
 41          int hTemplateFile
 42          );
 43        [DllImport("kernel32.dll ")]
 44        private static extern bool WriteFile(
 45          int hFile,
 46          byte[] lpBuffer,
 47          int nNumberOfBytesToWrite,
 48          ref   int lpNumberOfBytesWritten,
 49          ref   OVERLAPPED lpOverlapped
 50          );
 51        [DllImport("kernel32.dll ")]
 52        private static extern bool CloseHandle(
 53          int hObject
 54          );
 55        [DllImport("kernel32.dll ")]
 56       private static extern bool ReadFile(
 57          int hFile,
 58          out byte[] lpBuffer,
 59          int nNumberOfBytesToRead,
 60          ref int lpNumberOfBytesRead,
 61          ref OVERLAPPED lpOverlapped
 62        ); 
 63
 64        private int iHandle;
 65
 66        private bool _isWork;
 67     
 68        private const uint  GENERIC_READ = 0x80000000;
 69        private const uint GENERIC_WRITE = 0x40000000;
 70        #endregion
 71        IPort 成员#region IPort 成员
 72
 73
 74        private bool _IsOpen;
 75        public bool IsOpen
 76        {
 77            get
 78            {
 79                return _IsOpen;
 80            }
 81            private set
 82            {
 83                _IsOpen = value;
 84            }
 85        }
 86
 87        private string _Name;
 88        public string Name
 89        {
 90            get
 91            {
 92                return _Name;
 93            }
 94            set
 95            {
 96                _Name = value;
 97            }
 98        }
 99
        public bool WriteData(byte[] Data)
        {
            //for (int i = 0; i < Data.Length; i++)
            //    Output(BasePort, Data[i]); 这里原来也想用inpout32实现，但是从字节到int转换比较麻烦，试了几次没达到效果
            //return true;

            if (iHandle != -1)
            {
                OVERLAPPED x = new OVERLAPPED();
                int i = 0;
                WriteFile(iHandle, Data, Data.Length,
                  ref   i, ref   x);
                return true;
            }
            else
            {
                //throw new Exception("不能连接到打印机! ");
                return false;
            }
        }


        /**//// <summary>
        /// 读状态
        /// 用inpout32
        /// </summary>
        /// <param name="Len"></param>
        /// <returns></returns>
        public byte[] ReadData(int Len)
        {
            byte[] result ;//= new byte[Len];
            result = new byte[Len];
            for (int i = 0; i < result.Length; i++)
                result[i] = (byte)Input(BasePort + 1);
            return result;
        }


        /**//// <summary>
        /// 打开端口
        /// </summary>
        public void Open()
       {
           iHandle = CreateFile(Name, 0x40000000, 0, 0, 3, 0, 0);
           if (iHandle != -1)
           {
               this.IsOpen = true;
           }
           else
           {
               this.IsOpen = false;
           }

           this.IsOpen = true;
           _isWork = true;
           //开一个线程检测状态口状态
           new System.Threading.Thread(new System.Threading.ThreadStart(ReadState)).Start();
        }


        /**//// <summary>
        /// 关闭端口
        /// </summary>
        public void Close()
        {
           this.IsOpen =  !CloseHandle(iHandle);
           _isWork = false;
        }

        /**//// <summary>
        /// 端口基址
        /// </summary>
        private uint BasePort { get; set; }
        internal ParallelPort(String portName)
        {
            this.Name = portName;
            iHandle = -1;

            /**////用wql查询串口基址
            ManagementObjectSearcher search2 =
                    new ManagementObjectSearcher(
                        "ASSOCIATORS OF {Win32_ParallelPort.DeviceID='" + this.Name  + "'}");
            //本来最佳的wql是ASSOCIATORS OF {Win32_ParallelPort.DeviceID='" + this.Name  + "'} WHERE ASSCICLASS = Win32_PortResource
            //但是不知道为什么不返回结果，所以就做一个简单的遍历吧
            foreach (var i in search2.Get())
            {

                if (i.ClassPath.ClassName == "Win32_PortResource")
                {
                    //得到串口基址 大多数是0x378H
                    this.BasePort = System.Convert.ToUInt32( i.Properties["StartingAddress"].Value.ToString());

                    break;
                }


            }
            if (BasePort == 0)
                throw new Exception("不是有效端口");
            IsOpen = false;
        }

        #endregion

        IPort Members#region IPort Members

        public event PortStateChanged StateChanged;

        public event PortDataReceived DataReceive;

        public System.Windows.Forms.Form Parent
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        private int a { get; set; }

        /**//// <summary>
        /// 检测线程，当状态改变时，引发事件
        /// </summary>
        private void ReadState()
        {

            a = 0;
            int lastRead =a;
            while (_isWork)
            {
                lastRead = a;
                a = Input(BasePort + 1);
                if (a != lastRead)
                {
                    if (this.StateChanged != null)
                    {
                        PortChangedEvntAvrgs e = new PortChangedEvntAvrgs();
                        e.PortStatusByte = a;
                        this.StateChanged(this, e);
                    }
                   
                }
                System.Threading.Thread.Sleep(500);
                
            }
        }
        #endregion

        IDisposable Members#region IDisposable Members

        public void Dispose()
        {
            this.Close();
        }

        #endregion

        IPort Members#region IPort Members


        public void Update()
        {
            a = 0;
        }

        #endregion
    }
}