时间戳

首页 > 解决方案 > Java 客户端到 C# 服务器 TCP

java - Java 客户端到 C# 服务器 TCP

问题描述

问题是，当我发送最多 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;
    }

有任何想法吗 ？

标签： javac#tcp

解决方案

这篇文章的解决方案NetworkStream 正在读取不应该存在的数据

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();
}

问题是读取它需要大小并且想要获得那个大小你需要给它块并检查每个块并且读取不会从它停止的地方重新开始，直到它读取数量设置为读取含义如果我设置为读取 10然后如果它没有找到 10 那么它将读取它找到的内容作为示例它读取 6 它将返回 6 以及何时循环另一个时间 ti 读取其余部分它不会从 6 开始它从 0 开始并读取到 4 所以你覆盖您的数据，如果它从第一次尝试中读取 10，那么它将读取设置为完成，因此它不会从 0 开始，它需要读取已设置的数量以将读取重新设置到新的缓冲区位置。

推荐阅读