Esempio n. 1
0
        internal void Close()
        {
            if (_Listener != null)
            {
                Server.SendMessageTask task = _Listener.GetTask(this);

                int queueCount;

                lock (_QueueLockObj)
                {
                    _Closed    = true;
                    queueCount = _Queue.Count;
                }

                task.IncTotalQueueCount(0 - queueCount);
            }

            try
            {
                WorkSocket.Close();
            }
            catch
            {
            }
        }
Esempio n. 2
0
        internal void ASendFromServer(MessageFlag flag, UInt32 evt, UInt16 cableId, UInt32 channel, byte[] data)
        {
            while (BufferLength > 10 * 1024 * 1024)
            {
                System.Threading.Thread.Sleep(1);
            }

            Server.SendMessageTask task = _Listener.GetTask(this);

            bool needSetEvent = false;

            lock (task.LockObj)
            {
                needSetEvent = task.IncTotalQueueCount(1) == 0;

                lock (_QueueLockObj)
                {
                    IncBufferLength(data.Length);
                    _Queue.Enqueue(new Message(flag, evt, cableId, channel, data));
                }
            }

            if (needSetEvent)
            {
                task.Event.Set();
            }
        }
        readonly SendMessageTask[] _SendMessageTaskPool = null; //Send message task pool

        /// <summary>
        /// Init send message task pool
        /// </summary>
        private void InitSendMessageTaskPool()
        {
            for (int i = 0; i < _SendMessageTaskPool.Length; i++)
            {
                _SendMessageTaskPool[i] = new SendMessageTask(this);
            }

            for (int i = 0; i < _SendMessageTaskPool.Length; i++)
            {
                _SendMessageTaskPool[i].Start(i);
            }
        }
Esempio n. 4
0
        /// <summary>
        /// send message from queue. only server side use it.
        /// </summary>
        /// <returns>how many messages has been send</returns>
        internal int SendFromQueue()
        {
            lock (_QueueLockObj)
            {
                if (_Closed)
                {
                    return(0);
                }

                int queueCount = _Queue.Count;

                try
                {
                    Server.SendMessageTask task = _Listener.GetTask(this);

                    task.IncTotalQueueCount(0 - queueCount);

                    while (_Queue.Count > 0)
                    {
                        Message message = _Queue.Dequeue();

                        message.WriteToStream(_MStream);

                        IncBufferLength(0 - message.Data.Length);

                        if (_MStream.Length > MStreamCapacity / 2)
                        {
                            try
                            {
                                AsyncSend(_MStream.GetBuffer(), 0, (int)_MStream.Length);
                            }
                            catch (Exception e)
                            {
                                _Queue.Clear();

                                try
                                {
                                    if (WorkSocket.Connected)
                                    {
                                        WorkSocket.Close();
                                    }
                                }
                                catch
                                {
                                }
                                finally
                                {
                                    //Server.NTcpListener.RemoteSCB(this);
                                }

                                WriteError("SendFromQueue", e);
                                return(queueCount);
                            }

                            if (_MStream.Length > MStreamCapacity)
                            {
                                _MStream = new System.IO.MemoryStream(MStreamCapacity);
                            }
                            else
                            {
                                _MStream.SetLength(0);
                                _MStream.Position = 0;
                            }
                        }
                    }

                    if (_MStream.Length > 0)
                    {
                        try
                        {
                            AsyncSend(_MStream.GetBuffer(), 0, (int)_MStream.Length);
                        }
                        catch (Exception e)
                        {
                            _Queue.Clear();

                            try
                            {
                                if (WorkSocket.Connected)
                                {
                                    WorkSocket.Close();
                                }
                            }
                            catch
                            {
                            }
                            finally
                            {
                                //Server.NTcpListener.RemoteSCB(this);
                            }

                            WriteError("SendFromQueue", e);
                            return(queueCount);
                        }

                        if (_MStream.Length > MStreamCapacity)
                        {
                            _MStream = new System.IO.MemoryStream(MStreamCapacity);
                        }
                        else
                        {
                            _MStream.SetLength(0);
                            _MStream.Position = 0;
                        }
                    }
                }
                catch (Exception e)
                {
                    WriteError("SendFromQueue", e);
                }

                return(queueCount);
            }
        }