Question

问题是，当我发送多达40 KB的数据时，当我发送更多的数据时，一切正常，一半的时间收到的数据却一无所获，是否存在网络流的限制。即使我将数据压缩，我也可以做到这一点。从网络流或输出流确定问题是来自Java还是c＃

C＃服务器

private void ReadData(){

                                    if (networkStream.DataAvailable)
                                    {

                                        int size = GetBufferSize();
                                        Thread.Sleep(340);
                                        byte[] myReadBuffer = new byte[size];

                                        int numberOfBytesRead = 0;


                                        while (true)
                                        {
                                            numberOfBytesRead = networkStream.Read(myReadBuffer, 0, myReadBuffer.Length);

                                            if (numberOfBytesRead >= myReadBuffer.Length)
                                            {
                                                break;
                                            }
                                        }

                                        string str = Encoding.UTF8.GetString(myReadBuffer, 0, size);


                                        dynamic Message = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(str);
                                        // Android Message , JSON String
                                        if (OnAndroidMessage != null)
                                        {
                                            OnAndroidMessage(Message);
                                        }

                                    }
}
  private int GetBufferSize()
    {
        byte[] myReadBuffer = new byte[4];
        int numberOfBytesRead = 0;
        do
        {
            numberOfBytesRead = networkStream.Read(myReadBuffer, 0, myReadBuffer.Length);
        } while (networkStream.DataAvailable && numberOfBytesRead < myReadBuffer.Length);
        if (numberOfBytesRead > 0)
        {
            // reverse the byte array.
            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(myReadBuffer);
            }

            return BitConverter.ToInt32(myReadBuffer, 0);
        }
        else
        {
            return 0;
        }
    }

Java客户端 //我也对此进行了测试，但并没有将数据切入较小的速度，一半接收到的数据并非全部

        mBufferOut = socket.getOutputStream();

private void sendMessage(final String message) {

    if (mBufferOut != null && message != null) {
        try {
            byte[] data = message.getBytes("UTF-8");
            Log.d("_TAG", "Sending: " + message);
            Log.d("_TAG", "Message length: " + Integer.toString(data.length));

            mBufferOut.write(toByteArray(data.length));
            mBufferOut.flush();
            List<byte[]> divideArray = divideArray(data, 10000);
            for (byte[] dataChunk : divideArray) {
                Log.e("_TAG","CHUNK SIZE > " + Integer.toString(dataChunk.length));
                mBufferOut.write(dataChunk, 0, dataChunk.length);
                mBufferOut.flush();
            }

        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }
}
  private  List<byte[]> divideArray(byte[] source, int chunksize) {

        List<byte[]> result = new ArrayList<byte[]>();
        int start = 0;
        while (start < source.length) {
            int end = Math.min(source.length, start + chunksize);
            result.add(Arrays.copyOfRange(source, start, end));
            start += chunksize;
        }

        return result;
    }

有什么想法吗？

Answer 1

此帖子的解决方案NetworkStream is reading data that should not be there

static void ReadExact(Stream stream, byte[] buffer, int offset, int count)
{
    int read;
    while(count > 0 && (read = stream.Read(buffer, offset, count)) > 0) {
        offset += read;
        count -= read;
    }
    if(count != 0) throw new EndOfStreamException();
}

问题是“读取它需要大小”并想要获取该大小，您需要将其分配给块并检查每个块并且read不会从它停止的地方重新开始，直到它读取的数量被设置为read为止。如果我将其设置为read 10，那么如果找不到10，那么它将读取所找到的内容，例如它读取6，它将返回6当循环读取另一个时间ti时，它不会从6开始，而是从0开始，直到4读取，因此您覆盖了数据，如果它从第一次尝试中读取了10，则将读取设置为完成，因此不会从0开始，它需要读取已设置的数量以将读取的值重新设置为新的缓冲区位置。

Java客户端到C＃服务器TCP

1 个答案: