网络通信
public class NetClient
{
/// <summary>
/// 接收数据缓冲区大小64K
/// </summary>
public const int DefaultBufferSize = 64 * 1024;
public event EventHandler<EventArgCollection.ConnectionEventArgs> OnConnectionChanged;
public event EventHandler<EventArgCollection.SocketEventArgs> OnSocketEventRaised;
public event EventHandler<EventArgCollection.SocketErrorEventArgs> OnSocketErrorRaised;
#region 字段
/// <summary>
/// 客户端与服务器之间的会话类
/// </summary>
private Session _session;
/// <summary>
/// 客户端是否已经连接服务器
/// </summary>
private bool _isConnected = false;
/// <summary>
/// 报文解析器
/// </summary>
private DatagramResolver _resolver;
/// <summary>
/// 通讯格式编码解码器
/// </summary>
private Coder _coder;
/// <summary>
/// 接收数据缓冲区
/// </summary>
private byte[] _recvDataBuffer = new byte[DefaultBufferSize];
#endregion
#region 事件定义
/// <summary>
/// 已经连接服务器事件
/// </summary>
public event NetEvent ConnectedServer;
/// <summary>
/// 接收到数据报文事件
/// </summary>
public event NetEvent ReceivedDatagram;
/// <summary>
/// 连接断开事件
/// </summary>
public event NetEvent DisConnectedServer;
#endregion
#region 属性
/// <summary>
/// 返回客户端与服务器之间的会话对象
/// </summary>
public Session ClientSession
{
get
{
return _session;
}
}
/// <summary>
/// 返回客户端与服务器之间的连接状态
/// </summary>
public bool IsConnected
{
get
{
return _isConnected;
}
}
/// <summary>
/// 数据报文分析器
/// </summary>
public DatagramResolver Resovlver
{
get
{
return _resolver;
}
set
{
_resolver = value;
}
}
/// <summary>
/// 编码解码器
/// </summary>
public Coder ServerCoder
{
get
{
return _coder;
}
}
#endregion
#region 公有方法
/// <summary>
/// 默认构造函数,使用默认的编码格式
/// </summary>
public NetClient()
{
_coder = new Coder(Coder.EncodingMothord.Default);
}
/// <summary>
/// 构造函数,使用一个特定的编码器来初始化
/// </summary>
/// <param name="_coder">报文编码器</param>
public NetClient(Coder coder)
{
_coder = coder;
}
/// <summary>
/// 连接服务器
/// </summary>
/// <param name="ip">服务器IP地址</param>
/// <param name="port">服务器端口</param>
public virtual void Connect(string ip, int port)
{
/*
if (IsConnected)
{
Debug.Assert(_session != null);
Close();
}
*/
Socket newClientSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
try
{
IPEndPoint iep = new IPEndPoint(IPAddress.Parse(ip), port);
newClientSocket.BeginConnect(iep, new AsyncCallback(Connected), newClientSocket);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public virtual void Disconnect()
{
}
/// <summary>
/// 发送数据报文
/// </summary>
/// <param name="datagram"></param>
public virtual void Send(string datagram)
{
if (datagram.Length == 0)
{
return;
}
if (!_isConnected)
{
throw (new ApplicationException("没有连接服务器，不能发送数据"));
}
//获得报文的编码字节
byte[] data = _coder.GetEncodingBytes(datagram);
_session.ClientSocket.BeginSend(data, 0, data.Length, SocketFlags.None,
new AsyncCallback(SendDataEnd), _session.ClientSocket);
}
/// <summary>
/// 发送数据报文
/// </summary>
/// <param name="dataBytes"></param>
public virtual void SendBytes(byte[] dataBytes)
{
if (dataBytes.Length == 0)
{
return;
}
if (!_isConnected)
{
throw (new ApplicationException("没有连接服务器，不能发送数据"));
}
//获得报文的编码字节
byte[] data = _coder.GetEncodingBytes(dataBytes, _resolver);
_session.ClientSocket.BeginSend(data, 0, data.Length, SocketFlags.None,
new AsyncCallback(SendDataEnd), _session.ClientSocket);
}
#endregion
#region 受保护方法
/// <summary>
/// 数据发送完成处理函数
/// </summary>
/// <param name="iar"></param>
protected virtual void SendDataEnd(IAsyncResult iar)
{
Socket remoteSocket = (Socket)iar.AsyncState;
int sent = remoteSocket.EndSend(iar);
//Debug.Assert(sent != 0);
}
/// <summary>
/// 建立Tcp连接后处理过程
/// </summary>
/// <param name="iar">异步Socket</param>
protected virtual void Connected(IAsyncResult iar)
{
Socket cliectSocket = (Socket)iar.AsyncState;
try
{
cliectSocket.EndConnect(iar);
//创建新的会话
_session = new Session(cliectSocket);
_isConnected = true;
SetConnection(_isConnected);
//触发连接建立事件
if (ConnectedServer != null)
{
ConnectedServer(this, new NetEventArgs(_session));
}
_session.ClientSocket.BeginReceive(_recvDataBuffer, 0,
DefaultBufferSize, SocketFlags.None,
new AsyncCallback(ReceiveData), cliectSocket);
Mark(string.Format("连接成功"));
}
catch
{
//throw new Exception(ex.Message);
//_isConnected = false;
////WriteLog(sex, sex.ErrorCode.ToString());
//SetConnection(_isConnected);
}
}
/// <summary>
/// 关闭连接
/// </summary>
public virtual void Close()
{
if (!_isConnected)
{
return;
}
_session.Close();
_session = null;
_isConnected = false;
}
public virtual void SetConnection(bool IsConnected)
{
//if (!IsConnected && cliectSocket != null)
//{
// state.IsReceiveThreadAlive = false;
// try
// {
// if (statelst.Contains(state))
// statelst.Remove(state);
// state.workSocket.Shutdown(SocketShutdown.Both);
// state.workSocket.Close();
// }
// catch (Exception Ex)
// {
// //WriteLog(Ex, "When release socket connection.");
// }
//}
if (OnConnectionChanged != null)
OnConnectionChanged(this, new EventArgCollection.ConnectionEventArgs() { IsConnected = IsConnected });
}
public void Mark(string s)
{
var Id = System.Threading.Thread.CurrentThread.ManagedThreadId;
if (OnSocketEventRaised != null)
OnSocketEventRaised(null, new EventArgCollection.SocketEventArgs() { Msg = string.Format("[线程ID:{0}] {1}", Id, s) });
}
public void WriteLog(Exception exp, string msg)
{
if (OnSocketErrorRaised != null)
OnSocketErrorRaised(exp.Message, new EventArgCollection.SocketErrorEventArgs() { Exp = exp, Msg = msg });
}
/// <summary>
/// 数据接收处理函数
/// </summary>
/// <param name="iar">异步Socket</param>
protected virtual void ReceiveData(IAsyncResult iar)
{
Socket remote = (Socket)iar.AsyncState;
try
{
int recv = remote.EndReceive(iar);
if (recv == 0)
{
_session.TypeOfExit = Session.ExitType.NormalExit;
if (DisConnectedServer != null)
{
DisConnectedServer(this, new NetEventArgs(_session));
}
return;
}
byte[] receiveDataBytes = _coder.GetDecodingBytes(_recvDataBuffer, recv);
//ConcurrentDictionary<int, byte[]> dic = new ConcurrentDictionary<int, byte[]>();
//string receivedData = _coder.GetEncodingString(_recvDataBuffer, recv);
//通过事件发布收到的报文
if (ReceivedDatagram != null)
{
ICloneable copySession = (ICloneable)_session;
Session clientSession = (Session)copySession.Clone();
clientSession.RecvDataBuffer = new byte[receiveDataBytes.Length];
Array.ConstrainedCopy(receiveDataBytes, 0, clientSession.RecvDataBuffer, 0, receiveDataBytes.Length);
//clientSession.Datagram = newDatagram;
//发布一个报文消息
ReceivedDatagram(this, new NetEventArgs(clientSession));
if (_resolver != null)
{
//if (_session.Datagram != null && _session.Datagram.Length != 0)
//{
// receivedData = _session.Datagram + receivedData;
//}
//string[] recvDatagrams = _resolver.Resolve(ref receivedData);
//foreach (string newDatagram in recvDatagrams)
//{
// ICloneable copySession = (ICloneable)_session;
// Session clientSession = (Session)copySession.Clone();
// clientSession.Datagram = newDatagram;
// //发布一个报文消息
// ReceivedDatagram(this, new NetEventArgs(clientSession));
//}
////剩余的代码片断,下次接收的时候使用
//_session.Datagram = receivedData;
}
else
{
//ICloneable copySession = (ICloneable)_session;
//Session clientSession = (Session)copySession.Clone();
//clientSession.Datagram = receivedData;
//ReceivedDatagram(this, new NetEventArgs(clientSession));
}
}//end of if(ReceivedDatagram != null)
//继续接收数据
_session.ClientSocket.BeginReceive(_recvDataBuffer, 0, DefaultBufferSize, SocketFlags.None,
new AsyncCallback(ReceiveData), _session.ClientSocket);
}
catch (SocketException ex)
{
//主机端退出
if (10054 == ex.ErrorCode)
{
_session.TypeOfExit = Session.ExitType.ExceptionExit;
if (DisConnectedServer != null)
{
DisConnectedServer(this, new NetEventArgs(_session));
}
//_isConnected = false;
//WriteLog(ex, ex.ErrorCode.ToString());
}
else
{
//throw (ex);
}
}
catch (ObjectDisposedException ex)
{
if (ex != null)
{
ex = null;
//DoNothing;
}
//_isConnected = false;
}
}
#endregion
}
事件参数设定
public class EventArgCollection
{
/// <summary>
/// ConnectionEventArgs
/// </summary>
public class ConnectionEventArgs : EventArgs
{
public bool IsConnected { get; set; }
}
/// <summary>
/// SocketEventArgs
/// </summary>
public class SocketEventArgs : EventArgs
{
/// <summary>
/// ClientName
/// </summary>
public string ClientName { get; set; }
/// <summary>
/// IsConnect
/// </summary>
public bool IsConnect { get; set; }
/// <summary>
/// Message
/// </summary>
public string Msg { get; set; }
}
/// <summary>
/// ErrorEventArgs
/// </summary>
public class SocketErrorEventArgs : EventArgs
{
/// <summary>
/// Exception
/// </summary>
public Exception Exp { get; set; }
/// <summary>
/// Message
/// </summary>
public string Msg { get; set; }
}
}
/// <summary>
/// 网络通讯事件模型委托
/// </summary>
public delegate void NetEvent(object sender, NetEventArgs e);
连接处理通用
public class Transmitter_Network
{
public byte[] m_HeadBytes = new byte[4] { 0xfa, 0xfb, 0xfc, 0xfd }; //字头信息
#region ** 内部私有变量 **
NetClient m_NetClient;
private bool _isConnected = false;
#endregion
#region ** 构造函数 **
public Transmitter_Network()
{
_ThreadIsWork = true;
_ThreadIsPause = false;
CreateWorkThread();
_ThreadIsWork_Send = true;
_ThreadIsPause_Send = false;
CreateWorkThread_Send();
NetInitializeComponent();
}
#endregion
#region ** 数据传输 **
private void NetInitializeComponent()
{
m_NetClient = new NetClient(new Coder(Coder.EncodingMothord.Default));
//m_NetClient.Resovlver=new DatagramResolver("]}");
m_NetClient.Resovlver = new DatagramResolver(m_HeadBytes);
m_NetClient.ReceivedDatagram += M_NetClient_ReceivedDatagram;
m_NetClient.DisConnectedServer += M_NetClient_DisConnectedServer;
m_NetClient.ConnectedServer += M_NetClient_ConnectedServer;
m_NetClient.OnSocketErrorRaised += M_NetClient_OnSocketErrorRaised;
m_NetClient.OnSocketEventRaised += M_NetClient_OnSocketEventRaised;
//m_NetClient.Connect("192.168.1.166", 6500);
//m_NetClient.Connect("10.10.100.254", 8899);
}
//public event EventHandler<EventArgCollection.ConnectionEventArgs> OnConnectionChanged;
public event EventHandler<EventArgCollection.SocketEventArgs> OnSocketEventRaised;
public event EventHandler<EventArgCollection.SocketErrorEventArgs> OnSocketErrorRaised;
private void M_NetClient_OnSocketEventRaised(object sender, EventArgCollection.SocketEventArgs e)
{
//throw new NotImplementedException();
if (OnSocketEventRaised != null)
OnSocketEventRaised(null, new EventArgCollection.SocketEventArgs() { Msg = string.Format("[线程ID:{0}] {1}", "", e.Msg) });
}
private void M_NetClient_OnSocketErrorRaised(object sender, EventArgCollection.SocketErrorEventArgs e)
{
//throw new NotImplementedException();
if (OnSocketErrorRaised != null)
OnSocketErrorRaised(e.Exp.Message, new EventArgCollection.SocketErrorEventArgs() { Exp = e.Exp, Msg = e.Msg });
}
private void M_NetClient_ConnectedServer(object sender, NetEventArgs e)
{
//throw new NotImplementedException();
string info = string.Format("A Client:{0} connect server :{1}", e.ClientSession,
e.ClientSession.ClientSocket.RemoteEndPoint.ToString());
}
private void M_NetClient_DisConnectedServer(object sender, NetEventArgs e)
{
//throw new NotImplementedException();
string info;
if (e.ClientSession.TypeOfExit == Session.ExitType.ExceptionExit)
{
info = string.Format("A Client Session:{0} Exception Closed.",
e.ClientSession.ID);
}
else
{
info = string.Format("A Client Session:{0} Normal Closed.",
e.ClientSession.ID);
}
}
DateTime time_Main0 = DateTime.Now;
TimeSpan timeSpan_Main = new TimeSpan(0, 0, 0, 0);
int RDataCount = 0;
public delegate void RuntimeUpdateEventDelegate(TimeSpan TimeSpan, int RDataCount, int WDataCount);
public event RuntimeUpdateEventDelegate RuntimeUpdate;
public delegate void MyReceiveDataEventDelegate(byte[] dataBytes);
public event MyReceiveDataEventDelegate MyReceiveData;
public delegate void MyReceiveCommandEventDelegate(byte[] dataBytes);
public event MyReceiveCommandEventDelegate MyReceiveCommand;
public delegate void MySendDataEventDelegate(byte[] dataBytes);
public event MySendDataEventDelegate MySendData;
private void M_NetClient_ReceivedDatagram(object sender, NetEventArgs e)
{
//throw new NotImplementedException();
int DataByteLength = e.ClientSession.RecvDataBuffer.Length;
byte[] ReceiveDataBytes = new byte[DataByteLength];
Array.ConstrainedCopy(e.ClientSession.RecvDataBuffer, 0, ReceiveDataBytes, 0, DataByteLength);
if (MyReceiveData != null)
MyReceiveData(ReceiveDataBytes);
WdataCount = RDataCount - WdataCount;
RDataCount = Split_ReceiveDataBytes(ReceiveDataBytes);
DateTime time_Main1 = DateTime.Now;
timeSpan_Main = time_Main1.Subtract(time_Main0);
time_Main0 = time_Main1;
if (RuntimeUpdate != null)
RuntimeUpdate(timeSpan_Main, RDataCount, WdataCount);
}
object obj = new object();
private int Split_ReceiveDataBytes(byte[] ReceiveDataBytes)
{
int dataCount = 0;
for (int i = 0; i < ReceiveDataBytes.Length; i++)
{
if (i + 4 < ReceiveDataBytes.Length)
{
if (ReceiveDataBytes[i] == m_HeadBytes[0] && ReceiveDataBytes[i + 1] == m_HeadBytes[1] && ReceiveDataBytes[i + 2] == m_HeadBytes[2] && ReceiveDataBytes[i + 3] == m_HeadBytes[3])
{
//找到
int dataLength = Coder.ByteToInt32(ReceiveDataBytes[i + 4]);
byte[] dataBytes = new byte[dataLength];
if (i + 5 + dataLength - 1 < ReceiveDataBytes.Length)
{
Array.ConstrainedCopy(ReceiveDataBytes, i + 5, dataBytes, 0, dataLength);
lock (this)
{
if (CheckDigitByte(dataBytes))
{
//校验检测OK
if (dataBytes[0] == 0x25 && dataBytes[1] == 0x01 && dataBytes[2] == 0x02)
{
try
{
receive_Q.Enqueue(dataBytes);
}
catch
{
}
}
else
{
if (MyReceiveCommand != null)
MyReceiveCommand(dataBytes);
}
}
}
//ResolveReceiveData(dataBytes);
i = i + 5 + dataLength - 1;
dataCount++;
}
}
}
}
return dataCount;
}
/// <summary>
/// 校验检测
/// </summary>
/// <param name="dataBytes"></param>
/// <returns></returns>
public bool CheckDigitByte(byte[] dataBytes)
{
if (dataBytes.Length < 2) return false;
byte CheckDigitByte = dataBytes[dataBytes.Length - 1];
byte dataByte = new byte();
for (int i = 0; i < dataBytes.Length - 1; i++)
{
dataByte += dataBytes[i];
}
return dataByte == CheckDigitByte;
}
#endregion
#region ** 属性 **
public bool IsConnected
{
get
{
this._isConnected = m_NetClient.IsConnected;
return this._isConnected;
}
}
public object Dispatcher { get; private set; }
#endregion
#region ** 公共方法 **
/// <summary>
/// 模拟人连接
/// </summary>
public void NetworkConnect()
{
try
{
NetworkConnect("127.0.0.1", 8899);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 模拟人连接
/// </summary>
/// <param name="IP"></param>
/// <param name="Port"></param>
public void NetworkConnect(string IP, int Port)
{
try
{
m_NetClient.Connect(IP, Port);
Thread.Sleep(100); //等1秒
this._isConnected = m_NetClient.IsConnected;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 网络连接断开
/// </summary>
public void NetworkDisconnect()
{
try
{
m_NetClient.Disconnect();
Thread.Sleep(100); //等1秒
this._isConnected = m_NetClient.IsConnected;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void AddSendBytes(byte[] dataBytes)
{
try
{
//Cache_SendDataBytes.Add(dataBytes);
//入队
System.Diagnostics.Debug.WriteLine(string.Format("{0},{1}", Common.Converter.ByteConverter.ByteArrayToHexString(dataBytes), send_Q.Count));
send_Q.Enqueue(dataBytes);
}
catch (Exception)
{
//throw;
}
}
/// <summary>
/// 发送数据到模拟人
/// </summary>
/// <param name="dataBytes"></param>
private void SendBytes(byte[] dataBytes)
{
try
{
m_NetClient.SendBytes(dataBytes);
if (MySendData != null)
MySendData(dataBytes);
}
catch
{
//MessageBox.Show(ex.Message, "错误");
}
}
#endregion
#region ** 读取队列数据作业线程 **
//private List<byte[]> Cache_ReceiveDataBytes = new List<byte[]>();
Queue receive_Q = new Queue();
Thread WorkThread;
AutoResetEvent WorkResetEvent = new AutoResetEvent(true);
private bool _ThreadIsWork = false;
private bool _ThreadIsPause = false;
/// <summary>
/// 创建前线程
/// </summary>
public void CreateWorkThread()
{
this.WorkThread = new Thread(new ThreadStart(this.WorkThreedFun));
this.WorkThread.IsBackground = true;
this.WorkThread.Start();
}
/// <summary>
///
/// </summary>
public void DestroyWorkThread()
{
_ThreadIsWork = false;
Thread.Sleep(100);
WorkThread.DisableComObjectEagerCleanup();
}
/// <summary>
/// 执行线程函数
/// </summary>
private void WorkThreedFun()
{
while (true)
{
if (!_ThreadIsWork || _ThreadIsPause)
{
this.WorkResetEvent.WaitOne();
}
this.DoWork();
}
}
//int workRunTime = 0;
DateTime time_Main20 = DateTime.Now;
TimeSpan timeSpan_Main2 = new TimeSpan(0, 0, 0, 0);
public delegate void RuntimeUpdate2EventDelegate(TimeSpan TimeSpan, int DataCount);
//public event RuntimeUpdate2EventDelegate RuntimeUpdate2;
int WdataCount = 0;
/// <summary>
/// 取出数据
/// </summary>
private void DoWork()
{
while (receive_Q.Count > 0)
{
//出队
byte[] dataBytes = (byte[])receive_Q.Dequeue();
if (dataBytes != null)
{
//发送数据
//SendBytes(dataBytes);
if (MyReceiveCommand != null)
MyReceiveCommand(dataBytes);
}
//小于20条快速取出
if (receive_Q.Count < 20)
System.Threading.Thread.Sleep(10);
};
}
private byte[] ReadCacheData()
{
byte[] dataBytes = new byte[0];
//if (Cache_ReceiveDataBytes.Count >= 10)
//{
// dataBytes = Cache_ReceiveDataBytes[0];
// Cache_ReceiveDataBytes.RemoveAt(0);
//}
return dataBytes;
}
/// <summary>
/// 查找是否存在的字节数据
/// </summary>
/// <param name="byteDataArray"></param>
/// <param name="byteData"></param>
/// <returns></returns>
private bool InByte(byte[] byteDataArray, byte byteData)
{
if (byteDataArray == null)
return false;
for (int i = 0; i < byteDataArray.Length; i++)
{
if (byteDataArray[i] == byteData)
{
return true;
}
}
return false;
}
#endregion
#region ** 发送队列数据作业线程 **
Queue send_Q = new Queue();
Thread WorkThread_Send;
AutoResetEvent WorkResetEvent_Send = new AutoResetEvent(true);
private bool _ThreadIsWork_Send = false;
private bool _ThreadIsPause_Send = false;
/// <summary>
/// 创建前线程
/// </summary>
public void CreateWorkThread_Send()
{
this.WorkThread_Send = new Thread(new ThreadStart(this.WorkThreedFun_Send));
this.WorkThread_Send.IsBackground = true;
this.WorkThread_Send.Start();
}
/// <summary>
///
/// </summary>
public void DestroyWorkThread_Send()
{
_ThreadIsWork_Send = false;
Thread.Sleep(100);
WorkThread_Send.DisableComObjectEagerCleanup();
}
/// <summary>
/// 执行线程函数
/// </summary>
private void WorkThreedFun_Send()
{
while (true)
{
if (!_ThreadIsWork_Send || _ThreadIsPause_Send)
{
this.WorkResetEvent_Send.WaitOne();
}
this.DoWork_Send();
}
}
//int workRunTime_Send = 0;
DateTime time_Main20_Send = DateTime.Now;
TimeSpan timeSpan_Main2_Send = new TimeSpan(0, 0, 0, 0);
public delegate void RuntimeUpdate2_SendEventDelegate(TimeSpan TimeSpan, int DataCount);
//public event RuntimeUpdate2_SendEventDelegate RuntimeUpdate2_Send;
//int WdataCount_Send = 0;
/// <summary>
/// 取出数据
/// </summary>
private void DoWork_Send()
{
while (send_Q.Count > 0)
{
//出队
System.Diagnostics.Debug.WriteLine(string.Format("{0}", send_Q.Count));
byte[] dataBytes = (byte[])send_Q.Dequeue();
System.Diagnostics.Debug.WriteLine(string.Format("{0}", Common.Converter.ByteConverter.ByteArrayToHexString(dataBytes)));
if (dataBytes != null)
{
//发送数据
SendBytes(dataBytes);
}
System.Threading.Thread.Sleep(10);
};
}
private byte[] ReadCacheData_Send()
{
byte[] dataBytes = new byte[0];
//if (Cache_ReceiveDataBytes.Count >= 10)
//{
// dataBytes = Cache_ReceiveDataBytes[0];
// Cache_ReceiveDataBytes.RemoveAt(0);
//}
return dataBytes;
}
#endregion
#region ** 私有方法 **
#endregion
}
调用
Transmitter_Network Transmitter_Network = new Transmitter_Network();
Transmitter_Network.NetworkConnect(Ip, Port);
if(Transmitter_Network.IsConnected)
{
//成功
}
else
{
//失败
}
423
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
