目 录
第五章 串口和网络统一IO设计... 2
5.1 统一IO接口... 2
5.1.1 串口IO.. 4
5.1.2 网络IO.. 7
5.1.3 扩展应用... 12
5.2 IO管理器... 12
5.2.1 串口I O管理器... 13
5.2.2 网络IO管理器... 15
5.2.2.1 网络侦听... 16
5.2.2.2 连接远程服务器... 17
5.2.2.3 互斥操作... 18
5.3 小结... 19
作为通讯框架平台软件，IO是核心部分之一，涉及到与硬件设备、软件之间的信息数据交互，主要包括两部分：IO实例与IO管理器。IO实例负责直接对串口和网络进行操作；IO管理器负责对IO实例进行管理。
受应用环境的影响，IO操作过程中的确出现过一些问题，有些问题的解决也费了好长时间。并不是解决问题有多困难，而是无法确定到底是什么原因引起的。经过不断的完善，IO部分才逐渐稳定下来。
框架平台一大特点就是开发一套设备驱动（插件）同时支持串口和网络两种通讯方式，而两种通讯方式的切换只需要改动配制文件。
不同的设备类型和协议、不同的通讯方式，用堆代码的方式进行开发，根本无法适应不同场景的应用，提高了代码的维护成本，以及修改代码可能造成潜在的BUG，是让人很头疼的一件事。
在开始设计框架平台的时候，一个核心的思想就是把变的东西要设计灵活，把不变的东西设计稳定。对于设备的协议就是变的东西，对于IO部分就是相对不变的东西，那就需要对串口IO和网络IO进行整合。不仅在代码层面要运行稳定；在逻辑层面，不管是串口IO还是网络IO在框架内部是统一的接口，所有对IO的操作都会通过这个统一的接口来完成。
统一的IO接口代码如下：
public interface IIOChannel:IDisposable{ /// <summary> /// 同步锁 /// </summary> object SyncLock { get; } /// <summary> /// IO关键字，如果是串口通讯为串口号，如：COM1;如果是网络通讯为ip和端口，例如：127.0.0.1:1234 /// </summary> string Key { get; } /// <summary> /// IO通道，可以是COM，也可以是SOCKET /// </summary> object IO{get;} /// <summary> /// 读IO; /// </summary> /// <returns></returns> byte[] ReadIO(); /// <summary> /// 写IO /// </summary> int WriteIO(byte[] data); /// <summary> /// 关闭 /// </summary> void Close(); /// <summary> /// IO类型 /// </summary> CommunicationType IOType { get; } /// <summary> /// 是否被释放了 /// </summary> bool IsDisposed { get; }}串口IO和网络IO都继承自IIOChannel接口，完成特定的IO通讯操作。继承关系图如下：
原来串口IO操作使用是的MS自带的SerialPort组件，但是这个组件与一些小众工业串口卡不兼容，操作的时候出现异常"参数不正确"的提示。SerialPort组件本身是对Win32 API的封装，所以分析应该不是这个组件本身的问题。有网友反馈，如下图：
但是，从解决问题的成本角度来考虑，从软件着手解决是成本最低的、效率最高的。基于这方面的考虑，使用MOXA公司的PCOMM.DLL组件进行开发，并没有出现类似的问题。所以，在代码重构中使用了PCOMM.DLL组件，并且运行一直很稳定。
针对串口IO操作比较简单，主要是实现了ReadIO和WriteIO两个接口，代码如下：
public class sessionCom : ISessionCom{ ...... public byte[] ReadIO() { if (_ReceiveBuffer != null) { int num = InternalRead(_ReceiveBuffer, 0, _ReceiveBuffer.Length); if (num > 0) { byte[] data = new byte[num]; Buffer.BlockCopy(_ReceiveBuffer, 0, data, 0, data.Length); return data; } else { return new byte[] { }; } } else { return new byte[] { }; } } public int WriteIO(byte[] data) { int sendBufferSize = GlobalPRoperty.GetInstance().ComSendBufferSize; if (data.Length <= sendBufferSize) { return this.InternalWrite(data); } else { int successNum = 0; int num = 0; while (num < data.Length) { int remainLength = data.Length - num; int sendLength = remainLength >= sendBufferSize ? sendBufferSize : remainLength; successNum += InternalWrite(data, num, sendLength); num += sendLength; } return successNum; } } ......}
针对ReadIO接口函数，可以有多种操作方式，例如：读固定长度、判断结尾字符、一直读到IO缓存为空等。读固定长度，如果偶尔出现通讯干扰或丢失数据，这种方式会给后续正确读取数据造成影响；判断结尾字符，在框架内部的IO实现上又无法做到通用性；一直读到IO缓存为空，如果接收数据的频率大于从IO缓存读取的频率，那么会阻塞轮询调度线程。基于多方面的考虑，现场环境往往比想象的要复杂，在设置读超时的基础上，读一次就返回了。
还要考虑到现场实际的应用环境，例如：USB形式的串口容易松动，造成不稳定；9针串口损坏等情况。所以，有可能因为硬件环境改变引起无法正常对IO进行操作，这时候会通过TryOpen接口函数试着重新打开串口IO；另外，串口参数发生改变时，通过IOSettings接口函数重新配置参数。
网络IO通讯的本质是对Socket进行操作，框架平台现在支持TCP方式进行通讯；工作模块支持Server和Client两种，也就是开发一套设备驱动可以支持Tcp Server和Tcp Client两种数据交互方式。现在不支持UDP通讯方式，将会在后续进行完善。
发送和接收的代码实现比较简单，SessionSocket类中的ReadIO和WriteIO是用同步方式实现的；当并发通讯和自控通讯模式时，接收数据是用异步方式来完成的。当然，也可以使用完全的异步编程方式，使用SocketAsyncEventArgs操作类。SessionSocket操作代码实现如下：
public class SessionSocket : ISessionSocket{ public byte[] ReadIO() { if (!this.IsDisposed) { if (this.AcceptedSocket.Connected) { if (this.AcceptedSocket.Poll(10, SelectMode.SelectRead)) { if (this.AcceptedSocket.Available > this.AcceptedSocket.ReceiveBufferSize) { throw new Exception("接收的数据大于设置的接收缓冲区大小"); } #region int num = this.AcceptedSocket.Receive(this._ReceiveBuffer, 0, this._ReceiveBuffer.Length, SocketFlags.None); if (num <= 0) { throw new SocketException((int)SocketError.HostDown); } else { this._NoneDataCount = 0; byte[] data = new byte[num]; Buffer.BlockCopy(_ReceiveBuffer, 0, data, 0, data.Length); return data; } #endregion } else { this._NoneDataCount++; if (this._NoneDataCount >= 60) { this._NoneDataCount = 0; throw new SocketException((int)SocketError.HostDown); } else { return new byte[] { }; } } } else { throw new SocketException((int)SocketError.HostDown); } } else { return new byte[] { }; } } public int WriteIO(byte[] data) { if (!this.IsDisposed) { if (this.AcceptedSocket.Connected && this.AcceptedSocket.Poll(10, SelectMode.SelectWrite)) { int successNum = 0; int num = 0; while (num < data.Length) { int remainLength = data.Length - num; int sendLength = remainLength >= this.AcceptedSocket.SendBufferSize ? this.AcceptedSocket.SendBufferSize : remainLength; SocketError error; successNum += this.AcceptedSocket.Send(data, num, sendLength, SocketFlags.None, out error); num += sendLength; if (successNum <= 0 || error != SocketError.Success) { throw new SocketException((int)SocketError.HostDown); } } return successNum; } else { throw new SocketException((int)SocketError.HostDown); } } else { return 0; } }}ReadIO和WriteIO在操作过程中发生Socket失败后会抛出SocketException异常，框架平台捕捉异常后会对IO实例进行资源销毁。重新被动侦听或主动连接获得Socket实例。
考虑到硬件，由PC机的网卡引起的网络IO操作异常的可能比较小；但是，要考虑到连接到框架平台的各类终端（客户端）硬件设备，例如：DTU、无线路由、网络转换模块等；还涉及到通讯链路，例如：GPRS、2G/3G/4G等；不同的硬件特性、不同的通讯链路，多种原因可能会造成通讯链路失效，例如：另外一端的程序不稳定、无法释放资源等原因导致数据无法正常发送和接收；线路接头虚接导致链路时好时坏导致发送和接收数据不稳定；网络本身的原因出现Socket“假”连接的现象导致显示发送数据成功，而另一端却没有收到等等。
针对Socket通讯，原来在线程里定时轮询IO实例，通过IO实例向另一端发送心跳检测数据，如果发送失败，立即释放IO资源，这种操作方式的缺点是另一端会接收到一些冗余数据信息。重构时改变为另一种方式，对底层进行心跳在线检测，当进行异步发送和接收数据的时候，如果链路出现问题，异步函数会立即返回，并返回结果显示发送和接收0个数，对此进行判断而销毁IO实例资源。在初始化IO实例的时候，增加了对底层心跳检测功能，代码如下：
public SessionSocket(Socket socket){ uint dummy = 0; _KeepAliveOptionValues = new byte[Marshal.SizeOf(dummy) * 3]; _KeepAliveOptionOutValues = new byte[_KeepAliveOptionValues.Length]; BitConverter.GetBytes((uint)1).CopyTo(_KeepAliveOptionValues, 0); BitConverter.GetBytes((uint)(2000)).CopyTo(_KeepAliveOptionValues, Marshal.SizeOf(dummy));BitConverter.GetBytes((uint)(GlobalProperty.GetInstance().HeartPacketInterval)).CopyTo(_KeepAliveOptionValues, Marshal.SizeOf(dummy) * 2); socket.IOControl(IOControlCode.KeepAliveValues, _KeepAliveOptionValues, _KeepAliveOptionOutValues); socket.NoDelay = true; socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true); ......}通过发送、接收抛出异常和底层心跳检测两种方式对Socket IO实例有效性进行检测。对于正常通讯情况下的发送和接收操作很简单，但是也要通过技术手段防止各种意外情况，从而影响框架平台运行的稳定性。
对于通讯说简单也简单，说难也难，因应用场景和环境的原因难易程度不一样。在网络世界发展如火如荼的今天，网络任务调度、分布式消息、大数据处理等无不涉及到多点与多点之间的信息交互，所以在通讯基础上又发展出来各种协议、各种算法以及数据校验等。
把IO设计稳定，但是不代表没有扩展的余地。在《3.设备驱动的设计》的“3.7 IO数据交互设计”中介绍了具体的应用。在调用IRunDevice设备驱动的Send和Receive接口时会把IO实例以参数的形式传递进来，在二次开发过程中可以重写这两个函数，开发特定的发送和接收业务。
有网友问：串口通讯时，硬件设备一直在向软件发送数据，软件分析接收到的数据后进行数据处理，用SuperIO应该怎么实现？
这种单向通讯方式也是存在的，框架设计前已经考虑到这类情况，具体实现步骤如下：
IO管理器是对串口IO和网络IO实例进行管理，他们都继承自IIOChannelManager接口，但是各自的IO管理器的职能又有很大不同，网络IO管理器更复杂一些。继承关系结构图如下：
相对简单的多，因为串口IO动态改变的几率比较小，只是创建IO和关闭IO时通过事件反馈到串口监视窗体，主要代码如下：
public class SessionComManager : IOChannelManager,ISessionComManager<string, IIOChannel>{ ...... /// <summary> /// 建立并打开串口IO /// </summary> /// <param name="port"></param> /// <param name="baud"></param> /// <returns></returns> public ISessionCom BuildAndOpenComIO(int port, int baud) { ISessionCom com = new SessionCom(port, baud); com.TryOpen(); if (COMOpen != null) { bool openSuccess = false; if (com.IsOpen) { openSuccess = true; } else { openSuccess = false; } COMOpenArgs args = new COMOpenArgs(port, baud, openSuccess); this.COMOpen(com, args); } return com; } /// <summary> /// 闭关IO /// </summary> /// <param name="key"></param> public override void CloseIO(string key) { ISessionCom com = (ISessionCom)this.GetIO(key); base.CloseIO(key); if (COMClose != null) { bool closeSuccess = false; if (com.IsOpen) { closeSuccess = false; } else { closeSuccess = true; } COMCloseArgs args = new COMCloseArgs(com.Port, com.Baud, closeSuccess); this.COMClose(com, args); } } ......}网络IO管理器相对复杂一些，涉及到Socket的动态连接和断开，以及根据设备驱动设置的工作模式（Server或Client）切换对连接的处理方式。原来的时候，还负责通过线程定时对所有网络IO实例进行心跳检测，现在这部分被底层心跳检测所替代。
当侦听并接收到远程的连接实例后，会做两件事：
2.判断当前IO管理器是否存在相同的IP实例对象，如果存在，那么则销毁该IP实例对象。因为有可能这个实例对象已失效，至少认为远程的客户端认为当前的连接已经失效。所以，既然这样，我们双方达成共识，果断销毁这样的IP实例对象，接收新的IP连接实例。
接收连接实例对象的代码如下：
private void Monitor_SocketHanler(object source, AcceptSocketArgs e){ IRunDevice[] devs = DeviceManager.GetInstance().GetDevices(e.RemoteIP, WorkMode.TcpClient); if (devs.Length > 0) { DeviceMonitorLog.WriteLog(String.Format("有设备设置{0}为Tcp Client模式，此IP不支持远程主动连接", e.RemoteIP)); SessionSocket.CloseSocket(e.Socket); return; } CheckSameSessionSocket(e.RemoteIP); _ManualEvent.WaitOne(); //如果正在结束SOCKET操作，等待完成后再执行边接操作 ISessionSocket socket = new SessionSocket(e.Socket); SessionSocketConnect(socket);}单独开辟一个线程，获得所有工作模式为Client的设备驱动，并检测每一个设备驱动的通讯参数在IO管理器中是否存在相应的IO实例，如果不存在，那么则主动连接远程的服务器，连接成功后把连接的IO实例入到IO管理器。
实现的代码如下：
private void ConnectTarget(){ while (true) { if (!_ConnectThreadRun) { break; } IRunDevice[] devList = DeviceManager.GetInstance().GetDevices(WorkMode.TcpClient); for (int i = 0; i < devList.Length; i++) { try { if (!this.ContainIO(devList[i].DeviceParameter.NET.RemoteIP)) { ConnectServer(devList[i].DeviceParameter.NET.RemoteIP, devList[i].DeviceParameter.NET.RemotePort); } } catch (Exception ex) { devList[i].OnDeviceRuningLogHandler(ex.Message); } } System.Threading.Thread.Sleep(2000); }}当有新的连接，在检测是否有相同IP实例存在的时候，如果有相同IP实例存在，在销毁资源未结束之前，不能把新连接的IP实例放到IO管理器。因为相同IP的两个实例，一个在销毁资源、一个在创建资源，有可能把新连接的IP实例一起销毁掉。
防止这种情况的出现，使用ManualResetEvent信号互斥进行状态控制和改变，示意代码如下：
public class SessionSocketManager : IOChannelManager, ISessionSocketManager<string, IIOChannel>{ /// <summary> /// 初始状态为终止状态 /// </summary> private ManualResetEvent _ManualEvent = new ManualResetEvent(true); private void Monitor_SocketHanler(object source, AcceptSocketArgs e) { SessionSocketClose(e.RemoteIP); _ManualEvent.WaitOne(); //如果正在结束SOCKET操作，等待完成后再执行边接操作 ISessionSocket socket = new SessionSocket(e.Socket); SessionSocketConnect(socket); } private void SessionSocketClose(string key) { this._ManualEvent.Reset(); //为非终止状态 SessionSocket io = (SessionSocket)GetIO(key); if (io != null) { CloseIO(key); } this._ManualEvent.Set();//为终止状态 } private void SessionSocketConnect(ISessionSocket socket) { if (!this.ContainIO(socket.Key.ToString())) { this.AddIO(socket.Key.ToString(), (IIOChannel)socket); } }}IO这块的设计的思想是一个负责执行一个负责管理，IO实例是具体通道操作，IO管理器负责对IO进行管理，并协调设备和IO之间的关系和工作。
作者：唯笑志在
Email：504547114@QQ.com
QQ：504547114
.NET开发技术联盟：54256083
文档下载：http://pan.baidu.com/s/1pJ7lZWf
官方网址：http://www.bmpj.net
新闻热点
疑难解答
