/// <summary>
/// 数据第二层分配中心；把数据归类
/// </summary>
/// <param name="stateOne">连接属性</param>
/// <param name="statecode">收到的数据</param>
internal void codeManage(TransmitData stateOne, DataModel statecode)
{
if (statecode == null || stateOne == null)
{
return;
}
DataModel stateCode = null;
switch (statecode.State)
{
case CipherCode._commonCode: //普通数据信息;抛给普通Code去处理
stateCode = EncryptionDecrypt.deciphering(statecode.DateByte, stateOne);
CommonCodeManage(stateOne, stateCode);
break;
case CipherCode._bigDateCode: //抛给分包Code去处理
stateCode = EncDecSeparateDate.FileDecrypt(statecode.DateByte, stateOne); //返回一个带回复数据的模型
CommonCodeManage(stateOne, stateCode); //发送出去
break;
case CipherCode._fileCode: //抛给文件处理器去处理；如果返回null就不用发送了
byte[] haveDate = FileStart.ReceiveDateTO(statecode.DateByte, stateOne);
if (haveDate != null)
{
Send(stateOne, haveDate);
}
break;
}
}
/// <summary>
/// 接收到的普通数据处中心
/// </summary>
/// <param name="stateOne">StateBase</param>
/// <param name="stateCode">StateCode</param>
internal void CommonCodeManage(TransmitData stateOne, DataModel stateCode)
{
if (stateCode == null || stateOne == null)
{
return;
}
switch (stateCode.State)
{
case CipherCode._textCode: //文本信息
//发送回复数据
Send(stateOne, stateCode.ReplyDate);
OnAcceptString(stateOne.IpEndPoint, stateCode.Datestring); //触发文本收到的事件
break;
case CipherCode._photographCode: //图片信息
//发送回复数据
Send(stateOne, stateCode.ReplyDate);
OnAcceptByte(stateOne.IpEndPoint, stateCode.DateByte); //触发图片收到的事件
break;
case CipherCode._dateSuccess: //数据发送成功
stateOne.SendDate = null;
OndateSuccess(stateOne.IpEndPoint); //对方收到触发事件
break;
case 0: //说明这个数据只要直接回复给对方就可以了
Send(stateOne, stateCode.ReplyDate);
break;
}
}
/// <summary>
/// 最基础的Udp异步发送
/// </summary>
/// <param name="stateBase">StateBase</param>
/// <param name="bytes">数据</param>
override internal void Send(TransmitData stateBase, byte[] bytes)
{
if (stateBase == null)
{
return;
}
EndPoint remoteEndPoint = (EndPoint)stateBase.IpEndPoint;
byte[] sendDate = UdpPortSetGet.SetPort(Port, bytes);
try
{
state.WorkSocket.BeginSendTo(sendDate, 0, sendDate.Length, 0, remoteEndPoint, new AsyncCallback(SendCallback), state.WorkSocket);
}
catch { }
#region 异步发送的另一种方法
//try
//{
// EndPoint remoteEndPoint = (EndPoint)stateBase.IpEndPoint;
// state.SendSocketArgs.SetBuffer(bytes, 0, bytes.Length);
// state.SendSocketArgs.RemoteEndPoint = remoteEndPoint;
// bool bb= state.WorkSocket.SendToAsync(state.SendSocketArgs);
// if (bb == false)
// {
// state.SendSocketArgs = new SocketAsyncEventArgs();
// Send(stateBase, bytes);
// }
//}
//catch {}
#endregion
}
/// <summary>
/// 对文件进行续传;
/// </summary>
/// <param name="stateOne">StateBase</param>
/// <param name="fileLable">文件标签</param>
internal void FileContinue(TransmitData stateOne, int fileLable)
{
byte[] haveDate = FileStart.FileContinue(fileLable, stateOne);
if (haveDate == null)
{
throw new Exception("文件不存在或状态不在暂停状态");
}
Send(stateOne, haveDate);
}
/// <summary>
/// 服务器向客户端发送图片数据
/// </summary>
/// <param name="stateOne">StateBase</param>
/// <param name="data">未加密的数据</param>
internal void sendMessage(TransmitData stateOne, byte[] data)
{
if (stateOne == null)
{
return;
}
DataModel stateCode = new DataModel(CipherCode._photographCode, data);
//取得要发数据
byte[] sendDate = EncryptionDecrypt.encryption(stateCode, stateOne);
stateOne.SendDate = sendDate;
Send(stateOne, sendDate);
}
/// <summary>
/// 发送文本数据
/// </summary>
/// <param name="stateOne">StateBase</param>
/// <param name="data">未加密的数据</param>
internal void sendMessage(TransmitData stateOne, string data)
{
if (stateOne == null)
{
return;
}
//建立一个数据
DataModel stateCode = new DataModel(CipherCode._textCode, data);
//对一个数据进行加密-这里应该是把数据装入快速盒子
byte[] sendDate = EncryptionDecrypt.encryption(stateCode, stateOne);
//放入传输的快递盒子
stateOne.SendDate = sendDate;
//发送出去（）//在这里发送时再进行粘包处理 前面为粘包代码4位+sendDate包长度4位+sendDate
Send(stateOne, sendDate);
}
/// <summary>
/// 发送文件
/// </summary>
/// <param name="stateOne">StateBase</param>
/// <param name="fileName">文件地址</param>
/// <returns>文件标签,首先要注册文件发送系统；会返回一个整数型的文件标签；用来控制这个文件以后一系列操作</returns>
internal int FileSend(TransmitData stateOne, string fileName)
{
if (FileStart.fileSend == null)
{
throw new Exception("请先注册文件发送系统");
}
int haveInt = 0;
byte[] haveByte = null;
try
{
haveByte = FileStart.fileSend.Send(ref haveInt, fileName, stateOne);
}
catch { throw; }
Send(stateOne, haveByte);
return(haveInt);
}
/// <summary>
/// 发送完数据之后的回调函数
/// </summary>
/// <param name="ar">Clicent</param>
private void SendCallback(IAsyncResult ar)
{
TransmitData stateBase = (TransmitData)ar.AsyncState;
if (stateBase == null)
{
return;
}
Socket handler = stateBase.WorkSocket;
try
{
int bytesSent = handler.EndSend(ar);
}
catch
{
}
}
/// <summary>
/// 向服务器发送数据,最基础和原始的
/// </summary>
/// <param name="stateBase">StateBase</param>
/// <param name="data">发送的数据</param>
override internal void Send(TransmitData stateBase, byte[] data) //实现客户端虚方法
{
if (stateBase == null)
{
return;
}
Socket handler = stateBase.WorkSocket;
//对data数据进行粘包加密
StickPackage.EncryptionPackage(ref data);
try
{
//发送
handler.BeginSend(data, 0, data.Length, 0, new AsyncCallback(SendCallback), handler);
}
catch
{
}
}
/// <summary>
/// 向客户端发送数据,最基础的发送
/// </summary>
/// <param name="stateBase">TcpState</param>
/// <param name="data">发送的数据</param>
override internal void Send(TransmitData stateBase, byte[] data) //实现服务端虚方法
{
if (stateBase == null)
{
return;
}
StickPackage.EncryptionPackage(ref data);
//MessageBox.Show(data.Length.ToString()+"你好"+data[9].ToString());
try
{
stateBase.WorkSocket.BeginSend(data, 0, data.Length, 0, new AsyncCallback(SendCallback), stateBase);
}
catch (Exception Ex)
{
int i = Ex.Message.IndexOf("远程主机强迫关闭了一个现有的连接");
if (i != -1)
{
TcpTransmitBox stateOne = IPEndPointToState(stateBase.IpEndPoint);
socketRemove(stateOne, Ex.Message);
}
}
}
/// <summary>
/// 发送字节数据(基础虚方法)
/// </summary>
/// <param name="stateOne">StateBase</param>
/// <param name="data">发送的数据</param>
virtual internal void Send(TransmitData stateOne, byte[] data)
{
}
