internal class DoWork
        {
            string SERV, MES, ParseGlob;
            private bool doWork;
            private System.Threading.Thread thread;
            readonly EventWaitHandle wh = new AutoResetEvent(false);
            int IdCom, Port, ansLen;
            Regex rxNums = new Regex(@"^\d+$");
 
            internal DoWork(String server, String message, Int32 port, Int32 idcom, String Parse, Int32 dlina)
            {
                SERV = server;
                MES = message;
                Port = port;
                IdCom = idcom;
                ansLen = dlina;
                if (Parse != "")
                    ParseGlob = Parse;
            }
            public void ThreadStart()
            {
                doWork = true;
                thread = new Thread(Execute);
                thread.Start();
 
 
            }
            public void ThreadStop()
            {
                doWork = false;
                wh.Set();
 
            }
            void Execute()
            {
                try
                {
                    if (doWork)
                        Connect(SERV, MES, Port);
 
                }
                catch (Exception msg)
                {
                    logger.Trace("Execute() " + msg);
                    return;
                }
            }
 
            public void Connect(String server, String message, Int32 port)
            {
                try
                {
                    // Create a TcpClient.
                    // Note, for this client to work you need to have a TcpServer 
                    // connected to the same address as specified by the server, port
                    // combination.
 
                    // 
                    TcpClient client = new TcpClient(server, port);
 
                    // Translate the passed message into ASCII and store it as a Byte array.
                    Byte[] data = System.Text.Encoding.ASCII.GetBytes(message);
 
                    // Get a client stream for reading and writing.
                    //  Stream stream = client.GetStream();
 
                    NetworkStream stream = client.GetStream();
 
                    // Send the message to the connected TcpServer. 
                    stream.Write(data, 0, data.Length);
 
                    //   logger.Trace("Sent: {0}", message);
                    if (list[10] == "1")
                    {
                        logger.Trace("Sent: {0}", message);
                    }
                    doWork = false;
                    // Receive the TcpServer.response.
                    //  Thread.Sleep(2000);   
                    // Buffer to store the response bytes.
                    data = new Byte[256];
 
                    // String to store the response ASCII representation.
                    String responseData = String.Empty;
 
                    // Read the first batch of the TcpServer response bytes.
                    Int32 bytes = stream.Read(data, 0, data.Length);
                    responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
 
                    if (list[10] == "1")
                    {
                        logger.Trace("port_DataReceived " + responseData);
                    }
 
 
                }
                catch (ArgumentNullException e)
                {
                    logger.Trace("ArgumentNullException: {0}", e);
                    return;
                }
                catch (SocketException e)
                {
                    logger.Trace("SocketException: {0}", e);
                    Thread.Sleep(1000); 
                    return;
                }
            }
            public bool ThreadState()
            {
                if (doWork)
                    return true;
                else return false;
            }
        }

  stream.Close();