public void Close()
 {
     evForReconnect.Set();
     FinishChannel();
     WorkerThread.Stop(ref processingThread);
     WorkerThread.Stop(ref readingThread);
 }
 /// <summary>
 /// Stop
 /// </summary>
 /// <param name="workerThread"></param>
 public static void Stop(ref WorkerThread workerThread)
 {
     if (workerThread != null)
     {
         workerThread.Stop();
         workerThread = null;
     }
 }
        internal void Receive()
        {
            ResetFinishing();

            socket.ReceiveTimeout = 1000; // milliseconds

            lastReceiveTime = DateTime.Now;

            if (processingThread == null)
            {
                processingThread = new WorkerThread(e =>
                {
                    if (onProcessingThreadException != null)
                    {
                        onProcessingThreadException(this, new TcpChannelNotifyEventArgs(EnumNotificationLevel.Error, "Receive", null, e));
                    }
                });
                processingThread.Start(() =>
                {
                    List <byte> lstBts = BtsQueueToList();
                    if (lstBts != null && lstBts.Count > 0)
                    {
                        SetLastReceiveTime();
                        onReceived(this, new TcpChannelReceivedEventArgs(lstBts.ToArray()));
                    }
                });
            }

            readingThread = new WorkerThread(e =>
            {
                if (onReadingThreadException != null)
                {
                    onReadingThreadException(this, new TcpChannelNotifyEventArgs(EnumNotificationLevel.Error, "Receive", null, e));
                }
            });
            readingThread.Start(
                // ThreadStart Delegate
                () =>
            {
                if (IsFinishing || !IsWithinReceiveTimeout || !IsSocketConnected)
                {
                    throw new StopThreadException();
                }

                if (socket.Poll(POLL_TIMEOUT, SelectMode.SelectRead))
                {
                    if (socket.Available > 0)
                    {
                        // The socket is supposed to be connected and data are available.
                        byte[] buf = new byte[socket.Available];

                        int received = 0;
                        if ((received = socket.Receive(buf, 0, buf.Length, SocketFlags.None)) > 0 &&
                            onReceived != null && processingThread != null)
                        {
                            // Processing in dedicated thread
                            if (processingThread.IsThreadActive)
                            {
                                cqueBytes.Enqueue(buf);
                            }

                            processingThread.SetEvent();
                        }
                    }
                    else
                    if (onNoDataRead != null)
                    {
                        onNoDataRead(this, new TcpChannelNotifyEventArgs(EnumNotificationLevel.Debug, "Reading Thread, Start"));
                    }
                }
            },

                // AfterLoop Delegate
                () =>
            {
                WorkerThread.Stop(ref processingThread);

                if (IsSocketConnected)
                {
                    CloseSocket();
                }

                socket        = null;
                UnparsedBytes = null;

                bool isConnected = false;
                if (!IsFinishing && dlgtReconnect != null)
                {
                    isConnected = dlgtReconnect();      // reconnection after certain delay
                }
                if (!isConnected)
                {
                    Close();
                }
            }, 0);
        }