Question

I’m trying to create a chat with file transfer application using TCPSocket and here is my code..

SENDER:

public void sendData(string message)
{
    StreamWriter streamWriter = new StreamWriter(netStream); // netStream is 
                                                             // connected   
    streamWriter.WriteLine(message);
    streamWriter.WriteLine(message);
    logs.Add(string.Format("Message Sent! :{0}", message));
    //netStream.Flush();
    streamWriter.Flush();
}

RECEIVER:

private void ReceiveData()
{
    StreamReader streamReader = new StreamReader(ChatNetStream);

    StringBuilder dataAppends = new StringBuilder();
    bool doneTransfer = false;
    string data;
    while (!doneTransfer)
    {
        while ((data = streamReader.ReadLine()) != null)
        {
            dataAppends.Append(data);
        }
        doneTransfer = true;
        //ChatNetStream.Close();
        //streamReader
    }

    //do whatever i want with dataAppends.ToString() here..
   ReceiveData()
}

the problem is i always turn into infinite loop inside this statement

while ((data = streamReader.ReadLine()) != null)
{
    dataAppends.Append(data);
}

even if i put streamWriter.Flush() on my sender..

do i need to close/dispose the netStream/NetworkStream?

anyway, can i use only 1 socket or connection to send a File and send a chat at the same time..? or do i need to use a new socket connection everytime i send a file..

Answer 1

You get an infinite loop because StreamReader.ReadLine will only return null when the end of the stream is reached. For a network stream, “end of stream” means “the other side has closed its half of the connection”. Since the other side is your client, and it keeps the connection open while waiting for the user to type in more data, you will end up with an infinite loop.

What you want to do instead is fire off an operation that only completes if there is more data to read. There are two ways to go about this: either use a blocking read operation (on a dedicated thread, so that you don’t block your application’s other processing while waiting for messages), or use an async (event- or callback-based) approach.

For the synchronous (blocking) approach, see the documentation on NetworkStream.Read which includes example code that shows how to check if there is incoming data and how you can read it. The one point you absolutely need to know here is that when Read returns zero, it means that all data has been read and the connection has been closed from the other side (so you should close your end as well and not loop; the client has disconnected).

For low-level async network reads, the relevant operation is NetworkStream.BeginRead, which comes with its own example.

Both approaches are lower-level than what you currently have and will require you to manually assemble data inside a buffer and decide when “enough data” (i.e. a full line) has accumulated for you to process. You will then have to carefully pull that data out of the buffer and continue.

For a higher-level approach that still allows you some degree of orchestrating things, look into using client sockets (and in particular the two sync and async options there). This functionality is introduced by the TcpClient (and server-side the corresponding TcpListener) classes.

Finally, as jValdron’s comment says, you will either need a separate connection for transferring file data or engineer some custom protocol that allows you to interleave multiple kinds of data over the same network stream. The second solution is has generally more technical merit, but it will also be harder for you to implement correctly.