最近在写数据通信的时候用到的东西！希望对大家有帮助
/// <summary>
/// 获取或设置服务器IP地址
/// </summary>
public string serverIP = "";
/// <summary>
/// 获取或设置服务器端口
/// </summary>
public int serverPort = ;
/// <summary>
/// 连接对象
/// </summary>
private Socket conn = null;
/// <summary>
/// 监听连接对象
/// </summary>
private Socket listenSocket = null;
/// <summary>
/// 是否停止收发数据（true：停止收发；false：可以收发）
/// </summary>
private volatile bool stopFlag = true;
/// <summary>
/// 是否连接已断开(true:已断开；false：已连接)
/// </summary>
public volatile bool isSocketBroken = true;
private ManualResetEvent allDone = new ManualResetEvent(false);
/// <summary>
/// 抛出接收到的数据的事件
/// </summary>
public event NetInfoEventHandler.InfoEvent infoEvent;
/// <summary>
/// 抛出异常处理的事件
/// </summary>
public event ExceptionEventHandler.ExceptionEvent exceptionEvent; /// <summary>
/// 可以重连的次数，默认不重连
/// </summary>
public int canReconnectNum = ;
/// <summary>
/// 已经重连的次数
/// </summary>
public int ReconnectedNum = ; /// <summary>
/// 连接成功编码
/// </summary>
public static string SUCCESS_CONNECT = "SUCCESS";
/// <summary>
/// 连接异常编码
/// </summary>
public static string EXCEPTION_CONNECT = "CONNECT";
/// <summary>
/// 接收异常编码
/// </summary>
public static string EXCEPTION_RECEIVE = "RECEIVE";
/// <summary>
/// 发送异常编码
/// </summary>
public static string EXCEPTION_SEND = "SEND";
/// <summary>
/// 数据内容起始位置
/// </summary>
public static int GOOD_PARSER_OFFSET = ; /// <summary>
/// 写异常log的对象
/// </summary>
public WriteLog exceptionMsgLog;
/// <summary>
/// 最新接收到的数据
/// </summary>
public byte[] read;
/// <summary>
/// 最新发送的数据
/// </summary>
public byte[] write;
/// <summary>
/// 接收数据的任务
/// </summary>
private Task receiveDataTask;
/// <summary>
///监听连接的任务
/// </summary>
private Task lisenerTask;
/// <summary>
/// 数据开始标志
/// </summary>
private char DataBeginChar = '{';
/// <summary>
/// 数据结束标志
/// </summary>
private char DataEndChar = '}';
/// <summary>
/// 存放不完整的数据
/// </summary>
public byte[] totalReadByte;
public Socket workSocket = null; public Connection()
{
} /// <summary>
/// 构造函数
/// </summary>
/// <param name="serverIp"></param>
/// <param name="serverPort"></param>
/// <param name="errorLog"></param>
public Connection(string serverIp,int serverPort,WriteLog errorLog)
{
this.serverIP = serverIp;
this.serverPort = serverPort;
this.exceptionMsgLog = errorLog;
} /// <summary>
/// 构造函数
/// </summary>
/// <param name="serverIp"></param>
/// <param name="serverPort"></param>
/// <param name="errorLog"></param>
public Connection(string serverIp, int serverPort,int receiveBufferSize,int sendBufferSize, WriteLog errorLog)
{
this.serverIP = serverIp;
this.serverPort = serverPort;
this.exceptionMsgLog = errorLog;
this.read = new byte[receiveBufferSize];
this.write = new byte[sendBufferSize];
} /// <summary>
/// 建立连接
/// </summary>
/// <returns></returns>
public bool connect()
{
bool ret = false; try
{
//初始化
this.conn = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//开始连接
this.conn.Connect(this.serverIP, this.serverPort);
//连接成功，状态设置成已连接
this.isSocketBroken = false;
//开始接收数据
this.stopFlag = false;
if (this.read == null)
{
this.read = new byte[this.conn.ReceiveBufferSize];
}
if (this.write == null)
{
this.write = new byte[this.conn.SendBufferSize];
}
//异步接收数据
SocketError socketErr;
this.conn.BeginReceive(this.read, , this.read.Length, SocketFlags.None, out socketErr, new AsyncCallback(ReadCallback), this);
//启动后台任务同步接收数据
//this.receiveDataTask = new Task(() => this.syncReceive(this.conn, 0));
//this.receiveDataTask.Start();
//allDone.Set(); //连接处理成功
onConnectSuccess();
ret = true;
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(),EXCEPTION_CONNECT);
} return ret;
} /// <summary>
/// 连接成功的处理
/// </summary>
private void onConnectSuccess()
{
try
{
//把收到的对象转发给外面的事件
if (this.exceptionEvent != null)
{
exceptionEvent(this, new ExceptionEventHandler("", SUCCESS_CONNECT));
}
//重连次数清零
this.ReconnectedNum = ;
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
}
} /// <summary>
/// 连接出现异常的处理
/// </summary>
private void onConnectException(string exceptionInfo,string exceptionCode)
{
try
{
//把收到的对象转发给外面的事件
if (this.exceptionEvent != null)
{
exceptionEvent(this, new ExceptionEventHandler(exceptionInfo, exceptionCode));
}
//是否要重连
if (this.canReconnectNum > )
{
if (this.ReconnectedNum < this.canReconnectNum)
{
this.ReconnectedNum++;
if (this.conn != null)
{
this.disconnect();
}
this.connect();
}
}
else
{
this.isSocketBroken = true;
if (this.conn != null)
{
this.disconnect();
}
}
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
}
} /// <summary>
/// 接收数据出现异常的处理
/// </summary>
private void onReceiveException(string exceptionInfo, string exceptionCode)
{
try
{
onConnectException(exceptionInfo, exceptionCode);
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
}
} /// <summary>
/// 发送数据出现异常的处理
/// </summary>
private void onSendException(string exceptionInfo, string exceptionCode)
{
try
{
onConnectException(exceptionInfo, exceptionCode);
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
}
} /// <summary>
/// 建立连接
/// </summary>
/// <returns></returns>
public bool lisenter()
{
bool ret = false; try
{
IPEndPoint ipe = new IPEndPoint(IPAddress.Parse(this.serverIP), this.serverPort);
this.conn = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
this.conn.Bind(ipe);
//监听成功，状态设置成已连接
this.isSocketBroken = false;
//开始接收数据
this.stopFlag = false;
if (this.read == null)
{
this.read = new byte[this.conn.ReceiveBufferSize];
}
if (this.write == null)
{
this.write = new byte[this.conn.SendBufferSize];
}
//启动后台任务监听连接
this.lisenerTask = new Task(() => this.startListen());
this.lisenerTask.Start();
allDone.Set(); //连接处理成功
ret = true;
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_CONNECT);
} return ret;
} private void startListen()
{
try
{
conn.Listen(); while (!stopFlag)
{
allDone.Reset(); // Start an asynchronous socket to listen for connections.
//Console.WriteLine("Waiting for a connection...");
try
{
conn.BeginAccept(new AsyncCallback(AcceptCallback), conn);
}
catch (Exception e)
{
//Console.WriteLine(e.ToString());
} // Wait until a connection is made before continuing.
allDone.WaitOne();
}
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_CONNECT);
}
} class ReadSocketState
{
public Socket socket;
public volatile bool isStopFlag;
}
private ReadSocketState rss = null;
public const int DATA_OFFSET = ;
public void AcceptCallback(IAsyncResult ar)
{
try
{
Socket listenSocket = (Socket)ar.AsyncState;
Socket tempSocket = listenSocket.EndAccept(ar); // Signal the main thread to continue.
allDone.Set(); Connection newConn = new Connection(listenSocket.AddressFamily.ToString(),,this.exceptionMsgLog);
newConn.conn = tempSocket;
newConn.read = new byte[tempSocket.ReceiveBufferSize];
newConn.write = new byte[tempSocket.SendBufferSize];
newConn.isSocketBroken = false;
newConn.infoEvent += new NetInfoEventHandler.InfoEvent(ClientSocket_infoEvent);
newConn.exceptionEvent += new ExceptionEventHandler.ExceptionEvent(ClientSocket_ExceptionEvent);
//异步接收数据
SocketError socketErr;
newConn.conn.BeginReceive(newConn.read, , newConn.read.Length, SocketFlags.None, out socketErr, new AsyncCallback(ReadCallback), newConn);
////启动后台任务同步接收数据
//Task newTask = new Task(() => newConn.syncReceive(newConn.conn, 0));
//newTask.Start();
//newConn.allDone.Set();
//通知有一个连接连上来了
if (this.exceptionEvent != null)
{
exceptionEvent(newConn, new ExceptionEventHandler("客户端有新的客户连进来了", SUCCESS_CONNECT));
} //ThreadPool.QueueUserWorkItem(new WaitCallback(syncReceive), rss);
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_CONNECT);
} } public void ReadCallback(IAsyncResult ar)
{
Connection con = null;
try
{
con = (Connection)ar.AsyncState;
Socket socket = con.conn;
// Read data from the remote device.
SocketError socketErr;
int bytesRead = socket.EndReceive(ar, out socketErr); string temp = Encoding.UTF8.GetString(con.read);
if ( == bytesRead)
{
//errorLogger.log(ZDLogger.LVL_CRITCAL, CLASS_NM, "syncReceive", "Connection is broken!");
//throw new SocketException(System.Convert.ToInt32(SocketError.ConnectionReset));
}
else
{
if (temp.IndexOf("MARKET") < && temp.IndexOf("TEST") < )
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, temp);
}
string tmp = con.analyzeData(bytesRead, con); //if (tmp.IndexOf("MARKET") < 0)
//{
// this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, tmp);
//} //转为后台线程处理读取的数据，不阻塞主线程对数据的读取
if (!string.IsNullOrEmpty(tmp))
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, "启动任务前");
Task task = new Task(() => do_OneReceiveData(tmp, con));
task.Start();
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, "启动任务后");
}
} //异步接收数据
//SocketError socketErr;
con.conn.BeginReceive(con.read, , con.read.Length, SocketFlags.None, out socketErr, new AsyncCallback(ReadCallback), con); }
catch (SocketException se)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, se.StackTrace);
}
if (con != null)
{
con.onReceiveException(se.StackTrace, EXCEPTION_RECEIVE);
}
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
if (con != null)
{
con.onReceiveException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_RECEIVE);
}
}
} /// <summary>
/// 接收到客户端一条数据的处理
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ClientSocket_infoEvent(Connection sender, NetInfoEventHandler e)
{
try
{
NetInfo netInfo = e.EventArg;
//心跳数据不处理
if (netInfo.code == CommandCode.HEARTBIT)
{
return;
}
if (this.infoEvent != null)
{
infoEvent(sender, new NetInfoEventHandler(netInfo));
} }
catch (Exception ex)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
} /// <summary>
/// 接收到客户端异常的处理
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ClientSocket_ExceptionEvent(Connection sender, ExceptionEventHandler e)
{
try
{
string code = e.EventCode;
string msg = e.EventArg;
//把收到的对象转发给外面的事件
if (this.exceptionEvent != null)
{
exceptionEvent(sender, new ExceptionEventHandler(msg, code));
} }
catch (Exception ex)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
} public void syncReceive(object stateObj)
{
//ReadSocketState rss = (ReadSocketState)stateObj;
//Socket socket = rss.socket;
//try
//{
// DateTime timeBegin = DateTime.Now; // while (true)
// {
// if (socket == null || this.isSocketBroken)
// {
// continue;
// } // //NetInfo netInfo = readClientRequestMsg(socket, 5000); // if (socket.Poll(3000000, SelectMode.SelectRead)) // one-second timeout
// {
// int bytesRead = socket.Receive(this.read);
// //string temp = Encoding.UTF8.GetString(networkState.readBuffer);
// if (0 == bytesRead)
// {
// //errorLogger.log(ZDLogger.LVL_CRITCAL, CLASS_NM, "syncReceive", "Connection is broken!");
// throw new SocketException(System.Convert.ToInt32(SocketError.ConnectionReset));
// }
// string tmp = this.analyzeData(bytesRead); // //转为后台线程处理读取的数据，不阻塞主线程对数据的读取
// if (!string.IsNullOrEmpty(tmp))
// {
// Task task = new Task(() => this.do_OneReceiveClientData(tmp, socket));
// task.Start();
// }
// } // if (rss.isStopFlag)
// {
// socket.Close();
// break;
// }
// }
//}
//catch (System.ObjectDisposedException ode)
//{
// // this exception means socket_ is already closed when poll() is called
// Console.WriteLine(ode.ToString());
//}
//catch (Exception ex)
//{
// if (this.exceptionMsgLog != null)
// {
// this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
// }
// onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_CONNECT);
//} } public NetInfo readClientRequestMsg(Socket socket, int timeout)
{
try
{
byte[] data = syncReceive(socket, timeout);
// Timeout
if (data == null) return null; string msg = System.Text.ASCIIEncoding.ASCII.GetString(data, GOOD_PARSER_OFFSET, data.Length - GOOD_PARSER_OFFSET); //errorLogger.log(ZDLogger.LVL_CRITCAL, msg); NetInfo netInfo = new NetInfo();
netInfo.MyReadString(msg);
return netInfo;
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_CONNECT);
return null;
} } /// <summary>
/// 断开连接
/// </summary>
/// <returns></returns>
public bool disconnect()
{
bool ret = false; try
{
//this.conn.Close();
this.conn.Disconnect(true);
//连接断开成功，状态设置成已断开
this.isSocketBroken = true;
this.stopFlag = true;
if (this.receiveDataTask != null)
{
this.receiveDataTask.Dispose();
this.receiveDataTask = null;
}
if (this.lisenerTask != null)
{
this.lisenerTask.Dispose();
this.lisenerTask = null;
}
allDone.Set(); //连接断开处理成功
ret = true;
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
onConnectException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_CONNECT);
} return ret;
} /// <summary>
/// 同步接收数据（后台任务处理）
/// </summary>
/// <param name="socket"></param>
/// <param name="timeout"></param>
/// <returns></returns>
private byte[] syncReceive(Socket socket, int timeout)
{
try
{
DateTime timeBegin = DateTime.Now;
while (true)
{
if (socket == null || this.isSocketBroken)
{
continue;
} if (socket.Poll(, SelectMode.SelectRead)) // one-second timeout
{
int bytesRead = socket.Receive(this.read);
string temp = Encoding.UTF8.GetString(this.read);
if ( == bytesRead)
{
//errorLogger.log(ZDLogger.LVL_CRITCAL, CLASS_NM, "syncReceive", "Connection is broken!");
throw new SocketException(System.Convert.ToInt32(SocketError.ConnectionReset));
}
if (temp.IndexOf("MARKET") < )
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, temp);
}
string tmp = this.analyzeData(bytesRead,this); //if (tmp.IndexOf("MARKET") < 0)
//{
// this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, tmp);
//} //转为后台线程处理读取的数据，不阻塞主线程对数据的读取
if (!string.IsNullOrEmpty(tmp))
{
Task task = new Task(() => do_OneReceiveData(tmp,this));
task.Start();
}
}
else
{
//超时的话退出
//if (timeout != 0 && DateTime.Now.Subtract(timeBegin).TotalMilliseconds > timeout)
//break;
}
}
}
catch (System.ObjectDisposedException ode)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ode.StackTrace);
}
this.onReceiveException(ode.StackTrace, EXCEPTION_RECEIVE);
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
this.onReceiveException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_RECEIVE);
} return null;
} /// <summary>
/// 处理接收到的完整对象数据
/// </summary>
/// <param name="inPut"></param>
private void do_OneReceiveData(string inPut,Connection conn)
{
try
{
int fir = inPut.IndexOf('{');
int sec = inPut.IndexOf('}');
while (fir != - && sec != -)
{
string obj = inPut.Substring(fir + , sec - fir - );
inPut = inPut.Substring(sec + );//删除前面完整对象的字符串
//===========================//处理obj
fir = obj.IndexOf('(');
sec = obj.IndexOf(')');
string lenstr = obj.Substring(fir + , sec - );
lenstr = lenstr.Substring();
int len = int.Parse(lenstr);
obj = obj.Substring(sec + );//取完整对象的值
if (len == obj.Length) //完整正确的对象
{
NetInfo netInfo = new NetInfo();
netInfo.MyReadString(obj);
//把收到的对象转发给外面的事件
if (infoEvent != null)
{
conn.infoEvent(conn, new NetInfoEventHandler(netInfo));
}
}
fir = inPut.IndexOf('{');
sec = inPut.IndexOf('}');
}
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
}
} /// <summary>
/// 处理接收到客户端请求的完整对象数据
/// </summary>
/// <param name="inPut"></param>
private void do_OneReceiveClientData(string inPut,Connection socket)
{
try
{
int fir = inPut.IndexOf('{');
int sec = inPut.IndexOf('}');
while (fir != - && sec != -)
{
string obj = inPut.Substring(fir + , sec - fir - );
inPut = inPut.Substring(sec + );//删除前面完整对象的字符串
//===========================//处理obj
fir = obj.IndexOf('(');
sec = obj.IndexOf(')');
string lenstr = obj.Substring(fir + , sec - );
lenstr = lenstr.Substring();
int len = int.Parse(lenstr);
obj = obj.Substring(sec + );//取完整对象的值
if (len == obj.Length) //完整正确的对象
{
NetInfo netInfo = new NetInfo();
netInfo.MyReadString(obj);
//把收到的对象转发给外面的事件
if (infoEvent != null)
{
infoEvent(socket, new NetInfoEventHandler(netInfo));
}
}
fir = inPut.IndexOf('{');
sec = inPut.IndexOf('}');
}
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
}
} /// <summary>
/// 解析当前接收的数据块，并将完整的数据返回（没有完整数据返回空）
/// </summary>
/// <param name="len"></param>
/// <returns></returns>
public string analyzeData(int len,Connection con)
{
try
{
byte[] bytes = new byte[len];
List<byte> list = con.read.ToList();
//移除无效部分
list.RemoveRange(len, list.Count - len); bytes = list.ToArray<byte>().Clone() as byte[]; Boolean begin = false;
string inPut = Encoding.UTF8.GetString(bytes);
Boolean end = inPut.EndsWith(con.DataEndChar.ToString());
if (inPut.ElementAt() == con.DataBeginChar)
{
begin = true;
} if (begin && end)
{
//addByteToTotal(bytes);
return inPut;
}
else if (end) //处理最后的信息
{ addByteToTotal(bytes);
inPut = Encoding.UTF8.GetString(totalReadByte);
totalReadByte = null;
return inPut;
}
else //中间的
{
addByteToTotal(bytes);
inPut = Encoding.UTF8.GetString(totalReadByte);
int tEnd = inPut.LastIndexOf(con.DataEndChar);
string r = "";
string l = "";
if (tEnd >= )
{
r = inPut.Substring(, tEnd + );
l = inPut.Substring(tEnd + );
if (l.Length > )
{
totalReadByte = Encoding.UTF8.GetBytes(l);
}
}
return r;
}
}
catch(Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
this.onReceiveException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_RECEIVE);
return "";
}
} /// <summary>
/// 增加一个新读取的字节数组数据到总的字节数组数据中
/// </summary>
/// <param name="bytes"></param>
public void addByteToTotal(byte[] bytes)
{
if (bytes == null) return;
try
{
lock (this)
{
//用来存放原来残余的数据
byte[] oldData = null;
//用来计算残余数据的长度
int Count = ;
if (totalReadByte != null)
{
Count = totalReadByte.Length;
} if (Count != )
{
oldData = (byte[])totalReadByte.Clone();
}
totalReadByte = new byte[Count + bytes.Length];
if (Count > )
{
oldData.CopyTo(totalReadByte, );
}
bytes.CopyTo(totalReadByte, Count);
}
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
this.onReceiveException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_RECEIVE);
}
} /// <summary>
/// 发送netinfo数据
/// </summary>
/// <param name="obj"></param>
public void sendNetInfo(NetInfo obj)
{
try
{
this.sendMsg(CommonFunction.ObjectStringToBytes(obj.MyToString()));
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
this.onSendException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_SEND);
}
} /// <summary>
/// 发送数据
/// </summary>
/// <param name="data"></param>
public void sendMsg(byte[] data)
{
try
{
lock (this.conn)
{
int offset = ;
int size = data.Length;
size += offset;
while (offset < size)
{
int count = this.conn.Send(data, offset, size - offset, SocketFlags.None);
offset += count;
}
}
}
catch (Exception ex)
{
if (this.exceptionMsgLog != null)
{
this.exceptionMsgLog.log(LogLevel.SYSTEMERROR, ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString());
}
this.onSendException(ex.TargetSite + ex.Message + ex.StackTrace + ex.ToString(), EXCEPTION_SEND);
}
} /// <summary>
/// 接收到一个完整数据的处理，在调用的类中实现这个方法来实现各自的处理逻辑
/// </summary>
/// <param name="rawMsg"></param>
//public abstract void onReceiveData(string data); /// <summary>
/// 接收到一个监听连接发来的完整数据的处理，在调用的类中实现这个方法来实现各自的处理逻辑
/// </summary>
/// <param name="rawMsg"></param>
//public abstract void onReceiveClientData(string data, Socket socket); ///// <summary>
///// 接收数据出现异常的处理，在调用的类中实现这个方法来实现各自的处理逻辑
///// </summary>
///// <param name="rawMsg"></param>
//public abstract void onReceiveDataException(); ///// <summary>
///// 发送数据出现异常的处理，在调用的类中实现这个方法来实现各自的处理逻辑
///// </summary>
///// <param name="rawMsg"></param>
//public abstract void onSendDataException();
///// <summary>
///// 建立连接出现异常的处理，在调用的类中实现这个方法来实现各自的处理逻辑
///// </summary>
///// <param name="rawMsg"></param>
//public abstract void onConnectException();