public async void IncomingMsgAsync(object sender, MsgReceivedEventArgs e)
{
//check if message is from this peer
if (e.RemoteIp == this.LocalIpAddress)
{
//from this peer.
//no futher proccessing needed
if (forwardAll == false)
{
return;
}
}
//check if its from a new peer
if (e.BindingType == TransportType.UDP)
{
string remotePeeripAddress = e.RemoteIp;
bool peerKnown = DoesPeerExistByIp(remotePeeripAddress);
if (!peerKnown)
{
//not a known peer
await DirectConnectTCPAsync(remotePeeripAddress);
}
}
//check if its a blank UDP packet
//These are used as heart beats
if (e.Message.Length <= 0)
{
return;
}
//trigger sent message
MsgReceived?.Invoke(this, e);
}
/// <summary>
/// Sends a MsgReceived event
/// </summary>
/// <param name="msg"></param>
protected void OnMsgReceived(NetworkMsg msg)
{
if (msg is ClientDisconnectMsg)
{
OnDisconnected(false);
}
else
{
MsgReceived?.Invoke(this, new MsgEventArgs(msg));
}
}
private void _messageBus_MessageReceived(object sender, TinyMessageReceivedEventArgs e)
{
var msg = JsonConvert.DeserializeObject <Command>(Encoding.UTF8.GetString(e.Message));
if (msg.TargetID != null && msg.TargetID != ID)
{
return;
}
MsgReceived?.Invoke(this, msg);
_messages.Enqueue(msg);
}
private async void StartListening()
{
//set timeout for reading
while (this.IsPeerActive)
{
byte[] messageBin = null;
try
{
messageBin = await readUtil.ReadBytesAsync();
}
catch
{
//lost connection with peer
this.IsPeerActive = false;
peerStatusChange?.Invoke(this, new PeerEventArgs(this));
}
if (IsPeerActive == true)
{
MsgReceived?.Invoke(this, new MsgReceivedEventArgs(socketClient.RemoteAddress, messageBin, TransportType.TCP));
}
}
}
private void IncomingMsg(object sender, MsgReceivedEventArgs e)
{
//send message out
MsgReceived?.Invoke(this, e);
}
private void NewPeer_MsgReceived(object sender, MsgReceivedEventArgs e)
{
MsgReceived?.Invoke(this, e);
}
/// <summary>
/// 开启某个会话中的数据接收，直到会话关闭。
/// 解码错误释放该TcpClient资源
/// </summary>
/// <param name="session"></param>
public async void StartReadMsgAsync(Session session)
{
int bufferDataLength = 0;
byte[] buffer = new byte[1024 * 5];
try
{
while (true)
{
NetworkStream networkStream = session.TcpClient.GetStream();
//此次从网络数据流中读取到的数据长度
int length = await networkStream.ReadAsync(buffer, bufferDataLength, buffer.Length - bufferDataLength);
//若读到了流的末尾（被动关闭了连接？？）
if (length == 0)
{
CloseSeesion(session);
return;
}
bufferDataLength += length; //更新缓冲区中表示有效数据长度的变量
//开始解析
Int32 pointer = 0; byte[] tem; //pointer表示当前解析完的数据长度值
for (Int32 theMsgLength = BitConverter.ToInt32(buffer, pointer);
(bufferDataLength - pointer) >= theMsgLength + mataDataLength; //当buffer里未解析的数据还可以形成一条消息
theMsgLength = BitConverter.ToInt32(buffer, pointer))
{
pointer += mataDataLength;
Array.ConstrainedCopy(buffer, pointer, tem = new byte[theMsgLength], 0, theMsgLength);
//根据长度信息尝试解码消息，失败清空缓冲区，并继续接收数据
object data = coder.Decode(tem);
MsgReceived?.Invoke(this, new NetClientMsgEventArgs(session, Role.Server, data.GetType(), data));
pointer += theMsgLength;
if (bufferDataLength == pointer)
{
break;
}
}
//清理缓存中已处理的数据
if (pointer == bufferDataLength)
{
bufferDataLength = 0;
}
else if (pointer != 0)
{
Array.Copy(buffer, pointer, buffer, 0, pointer);
bufferDataLength -= pointer;
}
}
}
catch (Newtonsoft.Json.JsonException)//信息解码错误
{
CloseSeesion(session);
return;
}
catch (NetCoderException)
{
CloseSeesion(session);
return;
}
catch (System.ObjectDisposedException e)//已关闭连接
{
CloseSeesion(session);
}
catch (System.IO.IOException e)//被动关闭连接？？
{
if (e.InnerException is SocketException)
{
CloseSeesion(session);
}
else
{
throw e;
}
}
catch (System.InvalidOperationException)
{
CloseSeesion(session);
//throw;
}
}
public void Receive(NetworkMsg msg)
{
Msg = msg;
MsgReceived?.Invoke(this, new MsgEventArgs(msg));
}