Oops, I got the name wrong - it's not TcpSocket, it's just Socket (System.Net.Sockets.Socket) and the constructor takes a ProtocolType which in this case will be Tcp.
When using a Socket to read whatever comes in you should probably use an Async call and an internal buffer to get a reasonable sized chunck before trying to do something with it (since you could get your data 1 byte at a time).
Async was a bit daunting when I did it first but once you do a few functions you'll realise it's pretty simple:
1. Connect your socket using Socket.Connect (or BeginConnect if you want to do EVERYTHING Async but tbh if you are only connecting to one socket waiting for it to connect should be fine.
2. Set up your buffer (just a byte array of a fixed size)
3. Call Socket.BeginReceive to start looking for incoming data. The call will look something like this:
Code:
_connection.Socket.BeginReceive(_connection.Buffer, 0, _connection.Buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), _connection);
"ReceiveCallback" is the name of the method that is called by the Async opperation
4. Do your read from the socket in "ReceiveCallback":
Code:
private void ReceiveCallback(IAsyncResult result)
{
lock (_connection)
{
try
{
_connection.BytesRead += _connection.Socket.EndReceive(result);
...
_connection is my global object that holds the socket, buffer and some other application specific info.
_connection.Buffer now contains _connection.BytesRead worth of data. At this point you should check if the buffer is full (or has enough in for you to use in whatever way). If it is full you should do something with the data, and reset the BytesRead to 0 (don't need to empty the buffer, it will just be overwritten when you start writing at 0 next time).
5. At the end of the "ReceiveCallback" method once you have done something with your data (if the buffer is full) you need to do another async call to get the next blob of data:
Code:
_connection.Socket.BeginReceive(_connection.Buffer, _connection.BytesRead, _connection.Buffer.Length - _connection.BytesRead, SocketFlags.None, new AsyncCallback(ReceiveCallback), _connection);
This says: start receiving from Socket putting the data into _connection.Buffer, starting at byte _connection.BytesRead (i.e. if BytesRead is 50, Buffer[0] to Buffer[49] have data in them so start at Buffer[50]), up to a maximum of Buffer.Length - BytesRead (to make sure you don't read more than your buffer can take) and then async call "ReceiveCallback"
That sequence should read as much or as little data as is sent to you. You will get an exception on Socket.EndReceive if the connection is closed/broken.
I haven't done any Socket stuff in work and I've been too fed up of programming by the time I get home to do any "for fun" - I'd forgotten how nifty this stuff was
If you want to decipher the stuff you receive you will have to buffer the data until you have received a whole packet. The way to do this is to have two reading stages - reading the header and reading the message. The header will be a fixed length message (mine is 54 bytes - the length of a binary-serialized Int32) which tells you how long the following message is going to be. You read the header (BeginReceive(buffer, 0, 54...)), then set up your buffer to be that length and then just read until your buffer is exactly full at which point you can Deserialize the message and so something with it (and start reading the next header obv).
I think I'll write a stupid online game this weekend...
)