[连载]《C#通讯（串口和网络）框架的设计与实现》- 5.串口和网络统一IO设计

目 录

第五章 串口和网络统一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操作过程中的确出现过一些问题，有些问题的解决也费了好长时间。并不是解决问题有多困难，而是无法确定到底是什么原因引起的。经过不断的完善，IO部分才逐渐稳定下来。

5.1 统一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通讯操作。继承关系图如下：

5.1.1 串口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接口函数重新配置参数。

5.1.2 网络IO

网络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实例有效性进行检测。对于正常通讯情况下的发送和接收操作很简单，但是也要通过技术手段防止各种意外情况，从而影响框架平台运行的稳定性。

对于通讯说简单也简单，说难也难，因应用场景和环境的原因难易程度不一样。在网络世界发展如火如荼的今天，网络任务调度、分布式消息、大数据处理等无不涉及到多点与多点之间的信息交互，所以在通讯基础上又发展出来各种协议、各种算法以及数据校验等。

5.1.3 扩展应用

把IO设计稳定，但是不代表没有扩展的余地。在《3.设备驱动的设计》的“3.7 IO数据交互设计”中介绍了具体的应用。在调用IRunDevice设备驱动的Send和Receive接口时会把IO实例以参数的形式传递进来，在二次开发过程中可以重写这两个函数，开发特定的发送和接收业务。

有网友问：串口通讯时，硬件设备一直在向软件发送数据，软件分析接收到的数据后进行数据处理，用SuperIO应该怎么实现？

这种单向通讯方式也是存在的，框架设计前已经考虑到这类情况，具体实现步骤如下：

重写IRunDevice设备驱动中的Send接口函数，直接return返回，不进行发送数据。

重写IRunDevice设备驱动中的Receive接口函数，把接收上来的数据入到缓存里。

启动IRunDevice设备驱动中的IsStartTimer 的定时器，在DeviceTimer中定时分析缓存里的数据并处理数据。

查到可用的数据，调用RunIODevice(byte[])驱动函数，其他的代码不需要改动。

5.2 IO管理器

IO管理器是对串口IO和网络IO实例进行管理，他们都继承自IIOChannelManager接口，但是各自的IO管理器的职能又有很大不同，网络IO管理器更复杂一些。继承关系结构图如下：

5.2.1 串口I O管理器

相对简单的多，因为串口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);
}
}
......
}

5.2.2 网络IO管理器

网络IO管理器相对复杂一些，涉及到Socket的动态连接和断开，以及根据设备驱动设置的工作模式（Server或Client）切换对连接的处理方式。原来的时候，还负责通过线程定时对所有网络IO实例进行心跳检测，现在这部分被底层心跳检测所替代。

5.2.2.1 网络侦听

当侦听并接收到远程的连接实例后，会做两件事：

判断该连接实例的IP在设备管理器中的设备驱动是否设置为Client工作模式，如果是的话，那么则销毁该资源实例，并退出当前事务。设备驱动设置的IP参数和客户端的IP参数一致，但是两端的工作模式又都为Client模式。也就是说在一个网络内存在两个相同的IP和相同的Client工作模式，又要让他们之间进行通讯，这不符合C/S通讯的基本原理。所以，果断拒绝这样的连接并销毁资源。

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);
}

5.2.2.2 连接远程服务器

单独开辟一个线程，获得所有工作模式为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);
}
}

5.2.2.3 互斥操作

当有新的连接，在检测是否有相同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);
}
}
}

5.3 小结

IO这块的设计的思想是一个负责执行一个负责管理，IO实例是具体通道操作，IO管理器负责对IO进行管理，并协调设备和IO之间的关系和工作。

作者：唯笑志在

Email：504547114@qq.com

QQ：504547114

.NET开发技术联盟：54256083

文档下载：http://pan.baidu.com/s/1pJ7lZWf

官方网址：http://www.bmpj.net