/// <summary>
/// 需要发送的底层数据
/// </summary>
/// <param name="send">需要发送的底层数据</param>
/// <returns>带返回消息的结果对象</returns>
private OperateResult <NetHandle, byte[]> ReadCustomerFromServerBase(byte[] send)
{
// 核心数据交互
var read = ReadFromCoreServer(send);
if (!read.IsSuccess)
{
return(OperateResult.CreateFailedResult <NetHandle, byte[]>(read));
}
// 提炼数据信息
byte[] headBytes = new byte[InsideProtocol.HeadByteLength];
byte[] contentBytes = new byte[read.Content.Length - InsideProtocol.HeadByteLength];
Array.Copy(read.Content, 0, headBytes, 0, InsideProtocol.HeadByteLength);
if (contentBytes.Length > 0)
{
Array.Copy(read.Content, InsideProtocol.HeadByteLength, contentBytes, 0, read.Content.Length - InsideProtocol.HeadByteLength);
}
int customer = BitConverter.ToInt32(headBytes, 4);
contentBytes = InsideProtocol.CommandAnalysis(headBytes, contentBytes);
return(OperateResult.CreateSuccessResult((NetHandle)customer, contentBytes));
}
/// <summary>
/// 服务器端用于发送字节的方法
/// </summary>
/// <param name="customer">用户自定义的命令头</param>
/// <param name="bytes">实际发送的数据</param>
public void Send(NetHandle customer, byte[] bytes)
{
if (IsClientStart)
{
SendBytes(session, InsideProtocol.CommandBytes(customer, Token, bytes));
}
}
/// <summary>
/// 心跳线程的方法
/// </summary>
private void ThreadHeartCheck()
{
Thread.Sleep(2000);
while (true)
{
Thread.Sleep(1000);
if (!IsQuie)
{
byte[] send = new byte[16];
BitConverter.GetBytes(DateTime.Now.Ticks).CopyTo(send, 0);
SendBytes(session, InsideProtocol.CommandBytes(InsideProtocol.ProtocolCheckSecends, 0, Token, send));
double timeSpan = (DateTime.Now - session.HeartTime).TotalSeconds;
if (timeSpan > 1 * 8)//8次没有收到失去联系
{
if (isConnecting == 0)
{
LogNet?.WriteDebug(ToString( ), $"Heart Check Failed int {timeSpan} Seconds.");
ReconnectServer( );
}
if (!IsQuie)
{
Thread.Sleep(1000);
}
}
}
else
{
break;
}
}
}
/// <summary>
/// 数据处理中心
/// </summary>
/// <param name="session">会话对象</param>
/// <param name="protocol">消息的代码</param>
/// <param name="customer">用户消息</param>
/// <param name="content">数据内容</param>
internal override void DataProcessingCenter(AppSession session, int protocol, int customer, byte[] content)
{
if (protocol == InsideProtocol.ProtocolCheckSecends)
{
BitConverter.GetBytes(DateTime.Now.Ticks).CopyTo(content, 8);
SendBytes(session, InsideProtocol.CommandBytes(InsideProtocol.ProtocolCheckSecends, customer, Token, content));
session.HeartTime = DateTime.Now;
}
else if (protocol == InsideProtocol.ProtocolClientQuit)
{
TcpStateDownLine(session, true);
}
else if (protocol == InsideProtocol.ProtocolUserBytes)
{
//接收到字节数据
AcceptByte?.Invoke(session, customer, content);
}
else if (protocol == InsideProtocol.ProtocolUserString)
{
//接收到文本数据
string str = Encoding.Unicode.GetString(content);
AcceptString?.Invoke(session, customer, str);
}
else
{
// 其他一概不处理
}
}
/// <summary>
/// 关闭该客户端引擎
/// </summary>
public void ClientClose( )
{
IsQuie = true;
if (IsClientStart)
{
SendBytes(session, InsideProtocol.CommandBytes(InsideProtocol.ProtocolClientQuit, 0, Token, null));
}
IsClientStart = false; // 关闭客户端
thread_heart_check = null;
LoginSuccess = null; // 清空所有的事件
LoginFailed = null;
MessageAlerts = null;
AcceptByte = null;
AcceptString = null;
try
{
session.WorkSocket?.Shutdown(SocketShutdown.Both);
session.WorkSocket?.Close( );
}
catch
{
}
LogNet?.WriteDebug(ToString( ), "Client Close.");
}
/// <summary>
/// [自校验] 发送字节数据并确认对方接收完成数据，如果结果异常，则结束通讯
/// </summary>
/// <param name="socket">网络套接字</param>
/// <param name="headcode">头指令</param>
/// <param name="customer">用户指令</param>
/// <param name="send">发送的数据</param>
/// <returns>是否发送成功</returns>
protected OperateResult SendBaseAndCheckReceive(Socket socket, int headcode, int customer, byte[] send)
{
// 数据处理
send = InsideProtocol.CommandBytes(headcode, customer, Token, send);
// 发送数据
OperateResult sendResult = Send(socket, send);
if (!sendResult.IsSuccess)
{
return(sendResult);
}
// 检查对方接收完成
OperateResult <long> checkResult = ReceiveLong(socket);
if (!checkResult.IsSuccess)
{
return(checkResult);
}
// 检查长度接收
if (checkResult.Content != send.Length)
{
socket?.Close();
return(new OperateResult(StringResources.Language.CommandLengthCheckFailed));
}
return(checkResult);
}
/// <summary>
/// 重新开始接收下一次的数据传递
/// </summary>
/// <param name="session">网络状态</param>
/// <param name="isProcess">是否触发数据处理</param>
internal void ReBeginReceiveHead(AppSession session, bool isProcess)
{
try
{
byte[] head = session.BytesHead, Content = session.BytesContent;
session.Clear( );
session.WorkSocket.BeginReceive(session.BytesHead, session.AlreadyReceivedHead, session.BytesHead.Length - session.AlreadyReceivedHead,
SocketFlags.None, new AsyncCallback(HeadBytesReceiveCallback), session);
// 检测是否需要数据处理
if (isProcess)
{
// 校验令牌
if (CheckRemoteToken(head))
{
Content = InsideProtocol.CommandAnalysis(head, Content);
int protocol = BitConverter.ToInt32(head, 0);
int customer = BitConverter.ToInt32(head, 4);
// 转移到数据中心处理
DataProcessingCenter(session, protocol, customer, Content);
}
else
{
// 应该关闭网络通信
LogNet?.WriteWarn(ToString( ), StringResources.Language.TokenCheckFailed);
AppSessionRemoteClose(session);
}
}
}
catch (Exception ex)
{
SocketReceiveException(session, ex);
LogNet?.WriteException(ToString( ), ex);
}
}
/// <summary>
/// [自校验] 接收一条完整的同步数据，包含头子节和内容字节，基础的数据，如果结果异常，则结束通讯
/// </summary>
/// <param name="socket">套接字</param>
/// <param name="timeout">超时时间设置，如果为负数，则不检查超时</param>
/// <returns>包含是否成功的结果对象</returns>
/// <exception cref="ArgumentNullException">result</exception>
protected OperateResult <byte[], byte[]> ReceiveAndCheckBytes(Socket socket, int timeout)
{
// 30秒超时接收验证
TimeOut TimeOut = new TimeOut( )
{
DelayTime = timeout,
IsSuccessful = false,
StartTime = DateTime.Now,
WorkSocket = socket,
};
if (timeout > 0)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadPoolCheckTimeOut), TimeOut);
}
// 接收头指令
OperateResult <byte[]> headResult = Receive(socket, InsideProtocol.HeadByteLength);
if (!headResult.IsSuccess)
{
TimeOut.IsSuccessful = true;
return(OperateResult.CreateFailedResult <byte[], byte[]>(headResult));
}
TimeOut.IsSuccessful = true;
// 检查令牌
if (!CheckRemoteToken(headResult.Content))
{
socket?.Close( );
return(new OperateResult <byte[], byte[]>(StringResources.Language.TokenCheckFailed));
}
int contentLength = BitConverter.ToInt32(headResult.Content, InsideProtocol.HeadByteLength - 4);
// 接收内容
OperateResult <byte[]> contentResult = Receive(socket, contentLength);
if (!contentResult.IsSuccess)
{
return(OperateResult.CreateFailedResult <byte[], byte[]>(contentResult));
}
// 返回成功信息
OperateResult checkResult = SendLong(socket, InsideProtocol.HeadByteLength + contentLength);
if (!checkResult.IsSuccess)
{
return(OperateResult.CreateFailedResult <byte[], byte[]>(checkResult));
}
byte[] head = headResult.Content;
byte[] content = contentResult.Content;
content = InsideProtocol.CommandAnalysis(head, content);
return(OperateResult.CreateSuccessResult(head, content));
}
/// <summary>
/// 客户端向服务器进行请求，请求字符串数据，并返回状态信息
/// </summary>
/// <param name="customer">用户的指令头</param>
/// <param name="send">发送数据</param>
/// <returns>带返回消息的结果对象</returns>
public OperateResult <NetHandle, string> ReadCustomerFromServer(NetHandle customer, string send = null)
{
var read = ReadCustomerFromServerBase(InsideProtocol.CommandBytes(customer, Token, send));
if (!read.IsSuccess)
{
return(OperateResult.CreateFailedResult <NetHandle, string>(read));
}
return(OperateResult.CreateSuccessResult(read.Content1, Encoding.Unicode.GetString(read.Content2)));
}
/// <summary>
/// 客户端向服务器进行请求，请求字节数据
/// </summary>
/// <param name="customer">用户的指令头</param>
/// <param name="send">发送的字节内容</param>
/// <returns>带返回消息的结果对象</returns>
public OperateResult <byte[]> ReadFromServer(NetHandle customer, byte[] send)
{
return(ReadFromServerBase(InsideProtocol.CommandBytes(customer, Token, send)));
}
/// <summary>
/// 客户端向服务器进行请求，请求字符串数据，并返回状态信息，加密数据
/// </summary>
/// <param name="customer">用户的指令头</param>
/// <param name="send">发送数据</param>
/// <returns>带返回消息的结果对象</returns>
public OperateResult <NetHandle, byte[]> ReadCustomerFromServer(NetHandle customer, byte[] send)
{
return(ReadCustomerFromServerBaseInstructionsFirstEnDe(InsideProtocol.CommandBytes(customer, Token, send)));
}
/// <summary>
/// 向指定的通信对象发送字节数据
/// </summary>
/// <param name="session">连接对象</param>
/// <param name="customer">用户的指令头</param>
/// <param name="bytes">实际的数据</param>
public void SendMessage(AppSession session, int customer, byte[] bytes)
{
SendBytesAsync(session, InsideProtocol.CommandBytes(customer, Token, bytes));
}
/// <summary>
/// 服务器端用于发送字节的方法
/// </summary>
/// <param name="session">数据发送对象</param>
/// <param name="customer">用户自定义的数据对象，如不需要，赋值为0</param>
/// <param name="bytes">实际发送的数据</param>
public void Send(AppSession session, NetHandle customer, byte[] bytes)
{
SendBytes(session, InsideProtocol.CommandBytes(customer, Token, bytes));
}
/// <summary>
/// 服务器端用于数据发送文本的方法
/// </summary>
/// <param name="session">数据发送对象</param>
/// <param name="customer">用户自定义的数据对象，如不需要，赋值为0</param>
/// <param name="str">发送的文本</param>
public void Send(AppSession session, NetHandle customer, string str)
{
SendBytes(session, InsideProtocol.CommandBytes(customer, Token, str));
}
