Соединить 2 слушающих TCP сокета так, чтобы данные ходили между ними прозрачно

public class SimplexClient : IDisposable
    {
        public delegate void ByteReceivedEventHandler(object sender, byte[] data);
        public event ByteReceivedEventHandler ByteReceived;
 
        protected virtual void OnByteReceived(byte[] data)
        {
            ByteReceivedEventHandler handler = ByteReceived;
            if (handler != null) handler(this, data);
        }
 
        public delegate void DisconnectEventHandler(object sender);
        public event DisconnectEventHandler Disconnect;
        protected virtual void OnDisconnect()
        {
            var handler = Disconnect;
            if (handler != null) handler(this);
        }
 
        public string Label { get; set; }
 
        private const int BufferSize = 40000;
        private byte[] _buffer = new byte[BufferSize];
        public bool IsRunning { get; private set; }
        public IPEndPoint RemotePoint { get; private set; }
        public IPEndPoint LocalPoint
        {
            get
            {
                if (_client == null) return null;
                return _client.Client.LocalEndPoint as IPEndPoint;
            }
        }
        public NetworkStream RemoteStream
        {
            get
            {
                if (_client == null) return null;
                if (!_client.Connected) return null;
                return _client.GetStream();
            }
        }
        private TcpClient _client;
        private AutoResetEvent _connectEvent;
        
        public SimplexClient(IPAddress ipAddr, int port) : this(new IPEndPoint(ipAddr, port)) {}
        
        public SimplexClient(string ipAddr, int port) : this(IPAddress.Parse(ipAddr), port) {}
        
        public SimplexClient(IPEndPoint remotePoint)
        {
            _connectEvent = new AutoResetEvent(false);
            RemotePoint = remotePoint;
        }
 
        void ReInit()
        {
            DebugData("ReInit");
            _client.Close();
            _client = null;
            _connectEvent.Close();
            _connectEvent = new AutoResetEvent(false);
            Start();
        }
        
        public void Start()
        {
            DebugData("Start");
            IsRunning = true;
            _client = new TcpClient(AddressFamily.InterNetwork);
            _client.BeginConnect(RemotePoint.Address, RemotePoint.Port, OnConnected, null);
        }
 
        void DebugData(string msg)
        {
            Console.WriteLine("{0} : " + "({1})" + " : {2}", DateTime.Now, Label, msg);
            Debug.WriteLine("{0} : " + "({1})" + " : {2}", DateTime.Now, Label, msg);
        }
 
        private void OnConnected(IAsyncResult ar)
        {
            DebugData("OnConnected");
            try
            {
                _client.EndConnect(ar);
                StartRead();
            }
            catch (Exception ex)
            {
                DebugData(string.Format("OnConnected error: {0}", ex.Message));
                _connectEvent.Set();
            }
            DebugData("WaitOne");
            _connectEvent.WaitOne();
            if (IsRunning)
            {
                DebugData("AfterWaitOne");
                _client = new TcpClient(AddressFamily.InterNetwork);
                _client.BeginConnect(RemotePoint.Address, RemotePoint.Port, OnConnected, null);
            }
            else DebugData("OnConnected : RequestStop");
        }
 
        void StartRead()
        {
            DebugData("StartRead");
            var ns = RemoteStream;
            if (ns != null)
                ns.BeginRead(_buffer, 0, _buffer.Length, OnRead, null);
        }
 
        private void OnRead(IAsyncResult ar)
        {
            DebugData("OnRead");
            try
            {
                int countReaded = RemoteStream.EndRead(ar);
                if(countReaded != 0 && countReaded < BufferSize)
                {
                    DebugData("OnRead "+countReaded);
                    Array.Resize(ref _buffer, countReaded);
                    OnByteReceived(_buffer);
                }
            }
            catch (Exception ex)
            {
                DebugData(string.Format("OnRead error: {0}", ex.Message));
                _connectEvent.Set();
            }
            _buffer = new byte[BufferSize];
            //var ns = RemoteStream;
            //if (ns != null) ns.BeginRead(_buffer, 0, _buffer.Length, OnRead, null);
            try
            {
                var ns = RemoteStream;
                if (ns != null) ns.BeginRead(_buffer, 0, _buffer.Length, OnRead, null);
            }
            catch (Exception ex)
            {
                DebugData(string.Format("OnRead(2) error: {0}", ex.Message));
                OnDisconnect();
                //RequestStop();
                ReInit();
            }
        }
 
        public void Send(byte[] data)
        {
            var ns = RemoteStream;
            if (ns != null) 
                ns.BeginWrite(data, 0, data.Length, OnWrite, null);
        }
 
        private void OnWrite(IAsyncResult ar)
        {
            DebugData("OnWrite");
            try
            {
                RemoteStream.EndWrite(ar);
            }
            catch (Exception ex)
            {
                DebugData(string.Format("OnWrite error: {0}", ex.Message));
            }
        }
 
        public void Stop()
        {
            RequestStop();
        }
 
        void RequestStop()
        {
            DebugData("RequestStop");
            IsRunning = false;
            _connectEvent.Set();
            _client.Close();
        }
 
        public void Dispose()
        {
            RequestStop();
        }
    }

bool SocketConnected(Socket s)
        {
            bool part1 = s.Poll(1000, SelectMode.SelectRead);
            bool part2 = (s.Available == 0);
            if (part1 && part2) return false;
            return true;
        }