예제 #1
0
        private IReceivePackage InternalReceivePackageData(IList <byte[]> listBytes)
        {
            IReceivePackage rp = new ReceivePackage()
            {
                RemoteIP   = this.RemoteIP,
                RemotePort = this.RemotePort
            };

            if (listBytes.Count > 0)
            {
                if (this.Server.ServerConfig.StartCheckPackageLength)
                {
                    IRunDevice dev = InternalCheckCodeDevice(listBytes[0]);
                    if (dev != null)
                    {
                        rp.DeviceCode   = dev.DeviceParameter.DeviceCode;
                        rp.RequestInfos = ((RunDevice)dev).InternalReceiveChannelPackageData(this.Channel, listBytes);
                    }
                    else
                    {
                        foreach (byte[] b in listBytes)
                        {
                            rp.RequestInfos.Add(new RequestInfo(this.Key, b, this.Channel));
                        }
                    }
                }
                else
                {
                    foreach (byte[] b in listBytes)
                    {
                        rp.RequestInfos.Add(new RequestInfo(this.Key, b, this.Channel));
                    }
                }
            }
            return(rp);
        }
예제 #2
0
        private void ProcessReceive(SocketAsyncEventArgs e)
        {
            ISocketSession socketSession = (ISocketSession)e.UserToken;

            if (socketSession != null && socketSession.Client != null)
            {
                try
                {
                    if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
                    {
                        SocketAsyncEventArgsEx saeaEx = (SocketAsyncEventArgsEx)e;
                        if (saeaEx.NextOffset >= saeaEx.InitOffset + saeaEx.Capacity)
                        {
                            saeaEx.Reset();
                        }

                        saeaEx.DataLength += saeaEx.BytesTransferred;

                        IReceivePackage dataPackage = new ReceivePackage();
                        dataPackage.RemoteIP   = this.RemoteIP;
                        dataPackage.RemotePort = this.RemotePort;

                        #region 过滤数据

                        if (this.Server.ServerConfig.StartReceiveDataFliter)
                        {
                            IRunDevice[] devList = this.Server.DeviceManager.GetDevices(CommunicateType.NET);
                            if (devList != null && devList.Length > 0)
                            {
                                if (this.Server.ServerConfig.ControlMode == ControlMode.Loop ||
                                    this.Server.ServerConfig.ControlMode == ControlMode.Self ||
                                    this.Server.ServerConfig.ControlMode == ControlMode.Parallel)
                                {
                                    #region
                                    byte[] data = new byte[saeaEx.DataLength];
                                    Buffer.BlockCopy(saeaEx.ReceiveBuffer, saeaEx.InitOffset, data, 0, data.Length);
                                    IRunDevice dev = null;
                                    try
                                    {
                                        dev = devList.FirstOrDefault(d => d.DeviceParameter.DeviceCode == d.Protocol.GetCode(data));
                                    }
                                    catch (Exception ex)
                                    {
                                        this.Server.Logger.Error(true, ex.Message);
                                    }

                                    if (dev != null)
                                    {
                                        ProcessFliterData(dataPackage, saeaEx, dev);
                                    }

                                    #endregion
                                }
                                else if (this.Server.ServerConfig.ControlMode == ControlMode.Singleton)
                                {
                                    ProcessFliterData(dataPackage, saeaEx, devList[0]);
                                }
                            }
                        }
                        else
                        {
                            ProcessFliterData(dataPackage, saeaEx, null);
                        }

                        #endregion

                        saeaEx.SetBuffer(saeaEx.ReceiveBuffer, saeaEx.NextOffset, saeaEx.InitOffset + saeaEx.Capacity - saeaEx.NextOffset);

                        OnSocketReceiveData(dataPackage);

                        bool willRaiseEvent = socketSession.Client.ReceiveAsync(this.SocketAsyncProxy.SocketReceiveEventArgsEx);
                        if (!willRaiseEvent)
                        {
                            ProcessReceive(this.SocketAsyncProxy.SocketReceiveEventArgsEx);
                        }
                    }
                    else
                    {
                        OnCloseSocket();
                    }
                }
                catch (SocketException ex)
                {
                    OnCloseSocket();
                    this.Server.Logger.Error(true, ex.Message);
                }
                catch (Exception ex)
                {
                    this.Server.Logger.Error(true, ex.Message);
                }
            }
        }