Exemplo n.º 1
0
            private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
            {
                var startTime  = DateTime.Now;
                var lockObject = SourceChannel.LockObject;

                lock (lockObject)
                {
                    var masterStopWatch = new Stopwatch();
                    var requestBytes    = new byte[] { };

                    TimedThreadBlocker.Wait(requestDelay);

                    requestBytes = new byte[SerialPort.BytesToRead];

                    if (requestBytes.Length > 0)
                    {
                        Read(ref requestBytes, 0, requestBytes.Length, 0);
                        SourceChannel.Write(ref requestBytes, 0, requestBytes.Length);
                        TimedThreadBlocker.Wait(responseDelay);
                        masterStopWatch.Start();

                        var sequence = 0;
                        while (SourceChannel.NumberOfBytesAvailable > 0 && responseTimeout > masterStopWatch.ElapsedMilliseconds)
                        {
                            var responseBytes = new byte[SourceChannel.NumberOfBytesAvailable];

                            SourceChannel.Read(ref responseBytes, 0, responseBytes.Length, sequence++);
                            Write(ref responseBytes, 0, responseBytes.Length);
                        }

                        masterStopWatch.Stop();
                    }
                }
            }
Exemplo n.º 2
0
        private void TcpClientBeginReadCallback(IAsyncResult asyncResult)
        {
            var tcpClient = asyncResult.AsyncState as TcpClient;

            try
            {
                if (asyncResult.IsCompleted)
                {
                    if (tcpClient != null)
                    {
                        try
                        {
                            var startTime = DateTime.Now;
                            var sourceChannelLockObject = SourceChannel.LockObject;
                            lock (sourceChannelLockObject)
                            {
                                lock (lockObject)
                                {
                                    var readBuffer      = new byte[1500];
                                    var masterStopWatch = new Stopwatch();
                                    var requestBytes    = new byte[] { };
                                    var networkStream   = tcpClient.GetStream();

                                    this.tcpClient = tcpClient;

                                    TimedThreadBlocker.Wait(requestDelay);

                                    requestBytes = new byte[tcpClient.Available];

                                    if (requestBytes.Length > 0)
                                    {
                                        Read(ref requestBytes, 0, requestBytes.Length, 0);
                                        SourceChannel.Write(ref requestBytes, 0, requestBytes.Length);
                                        TimedThreadBlocker.Wait(responseDelay);
                                        masterStopWatch.Start();

                                        var sequence = 0;
                                        while (SourceChannel.NumberOfBytesAvailable > 0 && responseTimeout > masterStopWatch.ElapsedMilliseconds)
                                        {
                                            var responseBytes = new byte[SourceChannel.NumberOfBytesAvailable];

                                            SourceChannel.Read(ref responseBytes, 0, responseBytes.Length, sequence++);
                                            Write(ref responseBytes, 0, responseBytes.Length);
                                        }

                                        masterStopWatch.Stop();
                                    }

                                    networkStream.BeginRead(readBuffer, 0, 0, new AsyncCallback(TcpClientBeginReadCallback), tcpClient);

                                    return;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Trace.TraceError($"Error reading newtwork stream: {ex.Message}");
                        }
                    }
                }

                try
                {
                    tcpClient.Dispose();
                }
                catch (Exception ex)
                {
                    Trace.TraceError($"Error disposing TCP Client: {ex.Message}");
                }

                try
                {
                    tcpClients.Remove(tcpClient);
                }
                catch (Exception ex)
                {
                    Trace.TraceError($"Error removing TCP Client from list: {ex.Message}");
                }

                Interlocked.Decrement(ref numberOfTcpClients);
            }
            catch (Exception ex)
            {
                Trace.TraceError($"Error disposing TCP Client: {ex.Message}");
            }
        }