Reusing TcpClient and NetworkStream results in wrong data

Question

I'm writing a screen mirroring app on WPF. My original code sends a bitmap over TCP from a server to a client. The original code works fine, but closes and recreates the tcp connection every time it sends a frame. This results in 30 socket open and close per second, which I assume isn't the ideal way to do it.

So I tried to rewrite it to reuse the stream each time it sends the data, but the stream starts to spit out wrong data after a while.

public void SendStream(byte[] byteArray)
{
    /*
    _client = IsServer ? _server.AcceptTcpClient() : new TcpClient(IP.ToString(), Port);
    using (var clientStream = _client.GetStream())
    {
        var comp = Compress(byteArray);
        clientStream.Write(comp, 0, comp.Length);
    }
    */

    var comp = Compress(byteArray);
    _stream.Write(BitConverter.GetBytes(comp.Length), 0, 4);
    _stream.Write(comp, 0, comp.Length);
}

public byte[] ReceiveStream()
{
    /*
    _client = IsServer ? _server.AcceptTcpClient() : new TcpClient(IP.ToString(), Port);
    var stream = _client.GetStream();
    return Decompress(stream);
    */

    var lengthByte = new byte[4];
    _stream.Read(lengthByte, 0, 4);
    var length = BitConverter.ToInt32(lengthByte, 0);
    var data = new byte[length];
    _stream.Read(data, 0, length);
    return Decompress(new MemoryStream(data));
}

Compress and Decompress function are just wrappers around the built in DeflateStream.

I have checked that the sent comp.Length and received length are the same when the error happens.

Any ideas on whats going on? Thanks. It always throws an exception after at least a few frames, never the first one (at least that I've tried so far)

(It seems to happen faster when the bitmaps are larger in size i.e. when the compression algorithm doesn't do as much cause the screen is more complicated. Not 100% sure though)

Answer 1

Try doing the following:

    int receivedBytesCount = _stream.Read(data, 0, length);

The length variable you pass to the Read method is the maximum. The Read method may actually read less bytes than length. It will return the number of bytes it actually read. This will happen when your data is fragmented into TCP packets. You need to keep calling Read until you receive enough bytes and combine everything to get the full frame. You will need to adjust the offset in order to avoid overwriting the buffer. In the code you posted it is hardcoded to 0.