public void Send(YChannel chanael, IPacket pack)
{
if (chanael == null)
{
OnRaiseError("通道不能为空");
return;
}
chanael.Send(pack.Encoder());
}
protected virtual void OnConnected(YChannel e)
{
if (!clientSocket.Contains(e))
{
clientSocket.Add(e);
}
if (ClientConnected != null)
{
ClientConnected(this, e);
}
}
public override void Send(IPacket ipack)
{
if (!(ipack is MessagePack))
{
OnRaiseError("此方法只适用于默认协议解析，自定义协议请选择指定通道发送");
return;
}
MessagePack pack = ipack as MessagePack;
if (pack.TargetId == this.Id)
{
DeviceDataPacketReceived(null, pack);
return;
}
YChannel channel = null;
string nextId = base.NetTree.FintNextNode(this.Id, pack.TargetId);
if (string.IsNullOrEmpty(nextId))
{
if (pack.MsgType == MessageType.Back)
{
return;
}
if (this.ParentSocket == null)
{
if (!pack.FromId.Equals(this.Id))
{
MessagePack backPack = new MessagePack(pack.FromId, MessageType.Error, Encoding.UTF8.GetBytes("未找到该设备"));
this.Send(backPack);
}
OnRaiseError("未找到目标");
}
else
{
base.Send(pack);
}
}
else
{
if (string.IsNullOrEmpty(pack.FromId))
{
pack.FromId = this.Id;
}
channel = Find(nextId);
if (channel != null)
{
channel.Send(pack.Encoder());
return;
}
}
}
void transfer_Connected(object sender, System.Net.Sockets.Socket e)
{
YChannel client = new YChannel(e, socketPool, ChannelType.Client);
if (socketPool.Count < 2)
{
return;
}
client.RaiseErrored += sm_RaiseErrored;
client.SocketDisconnecting += sm_SocketDisconnecting;
client.DataPacketReceived += sm_DataPacketReceived;
client.DataPacketManager = this.Analysis;
client.Start();
if (CustomDecode == true)
{
NetNode node = new NetNode(client.Id, this.Id);
this.NetTree.Add(node);
OnConnected(client);
}
}
void sm_SocketDisconnecting(object sender, EventArgs e)
{
YChannel channel = sender as YChannel;
NetNode node = NetTree.FindNode(channel.Id);
clientSocket.Remove(channel);
if (node != null)
{
base.NetTree.Remove(node);
if (base.IsConnect == true)
{
SocketRegisterPacket pack = new SocketRegisterPacket(RegisterType.Delete, JsonConvert.SerializeObject(node));
base.ParentSocket.Send(pack);
}
}
if (ClientDisconnecting != null)
{
ClientDisconnecting(sender, e);
}
}
/// <summary>
/// 连接服务器
/// </summary>
/// <param name="address">地址</param>
/// <param name="port">端口</param>
/// <returns></returns>
public YChannel Connect(string address, uint port)
{
if (isInit == false)
{
new NullReferenceException("未初始化，请先初始化");
OnRaiseError("未初始化，请先初始化");
return(null);
}
Socket socket = transfer.ConnectParent(address, port);
parentSocket = new YChannel(socket, socketPool, ChannelType.Server, "");
parentSocket.DataPacketManager = this.Analysis;
parentSocket.RaiseErrored += parentSocket_RaiseErrored;
parentSocket.SocketDisconnecting += parentSocket_SocketDisconnecting;
parentSocket.DataPacketReceived += parentSocket_DataPacketReceived;
if (parentSocket != null)
{
parentSocket.Start();
if (CustomDecode == false)
{
Thread.Sleep(100);
parentSocket.Send(new SocketRegisterPacket(RegisterType.Add, netTree.Serialize()));
if (registerWaite.WaitOne(10000) == false)
{
parentSocket.Dispose();
new Exception("注册失败");
//OnRaiseError("注册失败");
// return null;
}
}
IsConnect = true;
return(parentSocket);
}
return(null);
}
/// <summary> /// 当收到来至客户端默认协议包时触发 /// </summary> /// <param name="sender"></param> /// <param name="pack"></param> public abstract void DeviceDataPacketReceived(YChannel sender, IPacket pack);
void sm_DataPacketReceived(object sender, IPacket e)
{
if (e is MessagePack)
{
MessagePack mpack = e as MessagePack;
if (mpack.MsgType == MessageType.Request)
{
if (base.IsConnect == true)
{
this.Send(mpack);
}
else
{
DeviceDataPacketReceived((YChannel)sender, mpack);
}
return;
}
if (mpack.TargetId.Equals(this.Id))
{
DeviceDataPacketReceived((YChannel)sender, mpack);
}
else
{
this.Send(mpack);
}
return;
}
if (e is SocketRegisterPacket)
{
SocketRegisterPacket spack = e as SocketRegisterPacket;
YChannel client = sender as YChannel;
switch (spack.RType)
{
case RegisterType.Add:
NetNode node = null;
try
{
node = JsonConvert.DeserializeObject <NetNode>(spack.Data);
}
catch { return; }
if (node != null)
{
if (string.IsNullOrWhiteSpace(node.ParentId))
{
node.ParentId = this.Id;
}
try
{
base.NetTree.Add(node);
}
catch (Exception ex)
{
client.Send(new SocketRegisterPacket(RegisterType.CallBack, this.Id, ex.Message));
OnRaiseError(ex.Message);
return;
}
if (node.ParentId != this.Id && base.IsConnect == true)
{
base.ParentSocket.Send(spack);
}
}
if (client != null)
{
client.Send(new SocketRegisterPacket(RegisterType.CallBack, this.Id));
client.Id = node.Id;
OnConnected(client);
}
break;
case RegisterType.CallBack: break;
case RegisterType.Delete:
NetNode dnode = null;
try
{
dnode = JsonConvert.DeserializeObject <NetNode>(spack.Data);
}
catch { return; }
if (dnode != null)
{
base.NetTree.Remove(dnode);
if (dnode.ParentId != this.Id && base.IsConnect == true)
{
base.ParentSocket.Send(spack);
}
}
break;
}
return;
}
DeviceDataPacketReceived((YChannel)sender, e);
}
private void ConnectCallBack(IAsyncResult e)
{
BeginConnectInfo ret = e as BeginConnectInfo;
AsyncConnectState state = e.AsyncState as AsyncConnectState;
if (state != null)
{
if (state.ConnectSocket != null)
{
try
{
state.ConnectSocket.EndConnect(e);
}
catch (Exception ex)
{
if (BeginConnectComplete != null)
{
BeginConnectComplete(
false,
ret != null ? ret.ErrorMessage : ex.Message,
state != null ? state.State : null
);
}
return;
}
}
}
if (e.IsCompleted)
{
if (state == null)
{
BeginConnectComplete(false, "连接错误", null);
return;
}
parentSocket = new YChannel(state.ConnectSocket, socketPool, ChannelType.Client);
parentSocket.DataPacketManager = this.Analysis;
parentSocket.RaiseErrored += parentSocket_RaiseErrored;
parentSocket.SocketDisconnecting += parentSocket_SocketDisconnecting;
parentSocket.DataPacketReceived += parentSocket_DataPacketReceived;
if (parentSocket != null)
{
parentSocket.Start();
if (CustomDecode == false)
{
Thread.Sleep(100);
parentSocket.Send(new SocketRegisterPacket(RegisterType.Add, netTree.Serialize()));
if (registerWaite.WaitOne(10000) == false)
{
parentSocket.SocketDisconnecting -= parentSocket_SocketDisconnecting;
parentSocket.Dispose();
OnRaiseError("注册失败");
return;
}
}
IsConnect = true;
BeginConnectComplete(true, "", state.State);
}
else
{
BeginConnectComplete(false, "连接错误", state.State);
}
}
else
{
if (BeginConnectComplete != null)
{
BeginConnectComplete(
false,
ret != null ? ret.ErrorMessage : "连接失败",
state != null ? state.State : null
);
}
}
}
private void ReConnectCallBack(IAsyncResult e)
{
AsyncConnectState state = e.AsyncState as AsyncConnectState;
if (state != null)
{
if (state.ConnectSocket != null)
{
try
{
state.ConnectSocket.EndConnect(e);
}
catch (Exception ex)
{
if (isReconnection == true)
{
ReConnect(this.parentSocket.Address, (uint)this.parentSocket.Port);
}
return;
}
}
}
if (e.IsCompleted)
{
if (parentSocket == null)
{
parentSocket = new YChannel(state.ConnectSocket, socketPool, ChannelType.Server);
parentSocket.DataPacketManager = this.Analysis;
parentSocket.RaiseErrored += parentSocket_RaiseErrored;
parentSocket.SocketDisconnecting += parentSocket_SocketDisconnecting;
parentSocket.DataPacketReceived += parentSocket_DataPacketReceived;
}
else
{
parentSocket.SetSocket(state.ConnectSocket, socketPool);
}
if (parentSocket != null)
{
parentSocket.Start();
if (customDecode == false)
{
Thread.Sleep(100);
parentSocket.Send(new SocketRegisterPacket(RegisterType.Add, netTree.Serialize()));
if (registerWaite.WaitOne(10000) == false)
{
parentSocket.SocketDisconnecting -= parentSocket_SocketDisconnecting;
parentSocket.Dispose();
OnRaiseError("注册失败");
if (isReconnection == true)
{
ReConnect(this.parentSocket.Address, (uint)this.parentSocket.Port);
}
return;
}
}
IsConnect = true;
BeginConnectComplete(true, "", state.State);
}
else
{
if (isReconnection == true)
{
ReConnect(this.parentSocket.Address, (uint)this.parentSocket.Port);
}
}
}
else
{
if (isReconnection == true)
{
ReConnect(this.parentSocket.Address, (uint)this.parentSocket.Port);
}
}
}
void service_ClientConnected(object sender, PoplarCloud.YChannel e)
{
//List<NetNode> list= service.NetTree.Root.ClientNode;
SetList();
//throw new NotImplementedException();
}
