Sending and receiving data over a network using TcpClient

Question

I need to develop a service that will connect to a TCP server  Main tasks are reading incoming messages and also sending commands to the server in ten minutes  like a synchronize command  For example  I used the TcpClient object as shown below       TcpClient tcpClient   new TcpClient    tcpClient Connect  x x x x   9999   networkStream   tcpClient GetStream    clientStreamReader   new StreamReader networkStream   clientStreamWriter   new  StreamWriter networkStream   while true       clientStreamReader Read       Also  when I need to write out something in any method  I use    clientStreamWriter write  xxx      Is this usage correct  Or is there a better way

User · Accepted Answer

Be warned - this is a very old and cumbersome "solution".

By the way, you can use serialization technology to send strings, numbers or any objects which are support serialization (most of .NET data-storing classes & structs are [Serializable]). There, you should at first send Int32-length in four bytes to the stream and then send binary-serialized (System.Runtime.Serialization.Formatters.Binary.BinaryFormatter) data into it.

On the other side or the connection (on both sides actually) you definetly should have a byte[] buffer which u will append and trim-left at runtime when data is coming.

Something like that I am using:

namespace System.Net.Sockets
{
    public class TcpConnection : IDisposable
    {
        public event EvHandler<TcpConnection, DataArrivedEventArgs> DataArrive = delegate { };
        public event EvHandler<TcpConnection> Drop = delegate { };

        private const int IntSize = 4;
        private const int BufferSize = 8 * 1024;

        private static readonly SynchronizationContext _syncContext = SynchronizationContext.Current;
        private readonly TcpClient _tcpClient;
        private readonly object _droppedRoot = new object();
        private bool _dropped;
        private byte[] _incomingData = new byte[0];
        private Nullable<int> _objectDataLength;

        public TcpClient TcpClient { get { return _tcpClient; } }
        public bool Dropped { get { return _dropped; } }

        private void DropConnection()
        {
            lock (_droppedRoot)
            {
                if (Dropped)
                    return;

                _dropped = true;
            }

            _tcpClient.Close();
            _syncContext.Post(delegate { Drop(this); }, null);
        }

        public void SendData(PCmds pCmd) { SendDataInternal(new object[] { pCmd }); }
        public void SendData(PCmds pCmd, object[] datas)
        {
            datas.ThrowIfNull();
            SendDataInternal(new object[] { pCmd }.Append(datas));
        }
        private void SendDataInternal(object data)
        {
            if (Dropped)
                return;

            byte[] bytedata;

            using (MemoryStream ms = new MemoryStream())
            {
                BinaryFormatter bf = new BinaryFormatter();

                try { bf.Serialize(ms, data); }
                catch { return; }

                bytedata = ms.ToArray();
            }

            try
            {
                lock (_tcpClient)
                {
                    TcpClient.Client.BeginSend(BitConverter.GetBytes(bytedata.Length), 0, IntSize, SocketFlags.None, EndSend, null);
                    TcpClient.Client.BeginSend(bytedata, 0, bytedata.Length, SocketFlags.None, EndSend, null);
                }
            }
            catch { DropConnection(); }
        }
        private void EndSend(IAsyncResult ar)
        {
            try { TcpClient.Client.EndSend(ar); }
            catch { }
        }

        public TcpConnection(TcpClient tcpClient)
        {
            _tcpClient = tcpClient;
            StartReceive();
        }

        private void StartReceive()
        {
            byte[] buffer = new byte[BufferSize];

            try
            {
                _tcpClient.Client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, DataReceived, buffer);
            }
            catch { DropConnection(); }
        }

        private void DataReceived(IAsyncResult ar)
        {
            if (Dropped)
                return;

            int dataRead;

            try { dataRead = TcpClient.Client.EndReceive(ar); }
            catch
            {
                DropConnection();
                return;
            }

            if (dataRead == 0)
            {
                DropConnection();
                return;
            }

            byte[] byteData = ar.AsyncState as byte[];
            _incomingData = _incomingData.Append(byteData.Take(dataRead).ToArray());
            bool exitWhile = false;

            while (exitWhile)
            {
                exitWhile = true;

                if (_objectDataLength.HasValue)
                {
                    if (_incomingData.Length >= _objectDataLength.Value)
                    {
                        object data;
                        BinaryFormatter bf = new BinaryFormatter();

                        using (MemoryStream ms = new MemoryStream(_incomingData, 0, _objectDataLength.Value))
                            try { data = bf.Deserialize(ms); }
                            catch
                            {
                                SendData(PCmds.Disconnect);
                                DropConnection();
                                return;
                            }

                        _syncContext.Post(delegate(object T)
                        {
                            try { DataArrive(this, new DataArrivedEventArgs(T)); }
                            catch { DropConnection(); }
                        }, data);

                        _incomingData = _incomingData.TrimLeft(_objectDataLength.Value);
                        _objectDataLength = null;
                        exitWhile = false;
                    }
                }
                else
                    if (_incomingData.Length >= IntSize)
                    {
                        _objectDataLength = BitConverter.ToInt32(_incomingData.TakeLeft(IntSize), 0);
                        _incomingData = _incomingData.TrimLeft(IntSize);
                        exitWhile = false;
                    }
            }
            StartReceive();
        }


        public void Dispose() { DropConnection(); }
    }
}

That is just an example, you should edit it for your use.

User · Answer

First of all  TCP does not guarantee that everything that you send will be received with the same read at the other end  It only guarantees that all bytes that you send will arrive and in the correct order   Therefore  you will need to keep building up a buffer when reading from the stream  You will also have to know how large each message is   The simplest ever is to use a non-typeable ASCII character to mark the end of the packet and look for it in the received data

User · Answer

First  I recommend that you use WCF   NET Remoting  or some other higher-level communication abstraction  The learning curve for  simple  sockets is nearly as high as WCF  because there are so many non-obvious pitfalls when using TCP IP directly   If you decide to continue down the TCP IP path  then review my  NET TCP IP FAQ  particularly the sections on message framing and application protocol specifications   Also  use asynchronous socket APIs  The synchronous APIs do not scale and in some error situations may cause deadlocks  The synchronous APIs make for pretty little example code  but real-world production-quality code uses the asynchronous APIs

User · Answer

I ve developed a dotnet library that might come in useful  I have fixed the problem of never getting all of the data if it exceeds the buffer  which many posts have discounted  Still some problems with the solution but works descently well https   github com NicholasLKSharp DotNet-TCP-Communication

User · Answer

I have had luck using the socket object directly  rather than the TCP client    I create a Server object that looks something like this  I ve edited some stuff such as exception handling out for brevity  but I hope that the idea comes across       public class Server         private Socket sock         You ll probably want to initialize the port and address in the        constructor  or via accessors  but to start your server listening        on port 8080 and on any IP address available on the machine        private int port   8080      private IPAddress addr   IPAddress Any          This is the method that starts the server listening      public void Start                    Create the new socket on which we ll be listening          this sock   new Socket              addr AddressFamily              SocketType Stream              ProtocolType Tcp              Bind the socket to the address and port          sock Bind new IPEndPoint this addr  this port               Start listening          this sock Listen this backlog              Set up the callback to be notified when somebody requests            a new connection          this sock BeginAccept this OnConnectRequest  sock                 This is the method that is called when the socket recives a request        for a new connection      private void OnConnectRequest IAsyncResult result                   Get the socket  which should be this listener s socket  from            the argument          Socket sock    Socket result AsyncState             Create a new client connection  using the primary socket to            spawn a new socket          Connection newConn   new Connection sock EndAccept result               Tell the listener socket to start listening again          sock BeginAccept this OnConnectRequest  sock             Then  I use a separate Connection class to manage the individual connection with the remote host   That looks something like this     public class Connection         private Socket sock         Pick whatever encoding works best for you   Just make sure the remote         host is using the same encoding      private Encoding encoding   Encoding UTF8       public Connection Socket s                this sock   s             Start listening for incoming data    If you want a multi-            threaded service  you can start this method up in a separate            thread           this BeginReceive                  Call this method to set this connection s socket up to receive data      private void BeginReceive                 this sock BeginReceive                  this dataRcvBuf  0                  this dataRcvBuf Length                  SocketFlags None                  new AsyncCallback this OnBytesReceived                   this                 This is the method that is called whenever the socket receives        incoming bytes      protected void OnBytesReceived IAsyncResult result                   End the data receiving that the socket has done and get            the number of bytes read          int nBytesRec   this sock EndReceive result              If no bytes were received  the connection is closed  at            least as far as we re concerned           if  nBytesRec  lt   0                        this sock Close                return                       Convert the data we have to a string          string strReceived   this encoding GetString              this dataRcvBuf  0  nBytesRec                  Now  do whatever works best with the string data             You could  for example  look at each character in the string            one-at-a-time and check for characters like the  end of text             character    u0003   from a client indicating that they ve finished            sending the current message   It s totally up to you how you want            the protocol to work              Whenever you decide the connection should be closed  call             sock Close   and don t call sock BeginReceive   again   But as long             as you want to keep processing incoming data                Set up again to get the next chunk of data          this sock BeginReceive              this dataRcvBuf  0              this dataRcvBuf Length              SocketFlags None              new AsyncCallback this OnBytesReceived               this              You can use your Connection object to send data by calling its Socket directly  like so     this sock Send this encoding GetBytes  Hello to you  remote host        As I said  I ve tried to edit the code here for posting  so I apologize if there are any errors in it

[c#] Sending and receiving data over a network using TcpClient

Be warned - this is a very old and cumbersome "solution".

Examples related to c#

Examples related to network-programming

Examples related to tcpclient