NamedPipeServerStream 接收 MAX=1024 字节，为什么？

Question

我正在使用 NamedPipeStream、客户端和服务器，我将数据从客户端发送到服务器，数据是一个包含二进制数据的序列化对象。

当服务器端接收到数据时，它总是有 MAX 1024 大小，而客户端发送更多！！因此，当尝试序列化数据时，这会导致以下异常：“未终止的字符串。预期的分隔符：”。路径“数据”，第 1 行，位置 1024。”

服务器缓冲区大小定义为：

protected const int BUFFER_SIZE = 4096*4;
var stream = new NamedPipeServerStream(PipeName,
                                                   PipeDirection.InOut,
                                                   1,
                                                   PipeTransmissionMode.Message,
                                                   PipeOptions.Asynchronous,
                                                   BUFFER_SIZE,
                                                   BUFFER_SIZE,
                                                   pipeSecurity);


        stream.ReadMode = PipeTransmissionMode.Message;

我正在使用 ：

    /// <summary>
    /// StreamWriter for writing messages to the pipe.
    /// </summary>
    protected StreamWriter PipeWriter { get; set; }

读取函数：

/// <summary>
/// Reads a message from the pipe.
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
protected static byte[] ReadMessage(PipeStream stream)
{
    MemoryStream memoryStream = new MemoryStream();

    byte[] buffer = new byte[BUFFER_SIZE];

    try
    {
        do
        {
            if (stream != null)
            {
                memoryStream.Write(buffer, 0, stream.Read(buffer, 0, buffer.Length));
            }

        } while ((m_stopRequested != false) && (stream != null) && (stream.IsMessageComplete == false));
    }
    catch
    {
        return null;
    }
    return memoryStream.ToArray();
}


protected override void ReadFromPipe(object state)
{
    //int i = 0;
    try
    {
        while (Pipe != null && m_stopRequested == false)
        {
            PipeConnectedSignal.Reset();

            if (Pipe.IsConnected == false)
            {//Pipe.WaitForConnection();
                var asyncResult = Pipe.BeginWaitForConnection(PipeConnected, this);

                if (asyncResult.AsyncWaitHandle.WaitOne(5000))
                {
                    if (Pipe != null)
                    {
                        Pipe.EndWaitForConnection(asyncResult);
                        // ...
                        //success;
                    }
                }
                else
                {
                    continue;
                }
            }
            if (Pipe != null && Pipe.CanRead)
            {
                byte[] msg = ReadMessage(Pipe);

                if (msg != null)
                {
                    ThrowOnReceivedMessage(msg);
                }
            }
        }
    }
    catch (System.Exception ex)
    {
        System.Diagnostics.Debug.WriteLine(" PipeName.ReadFromPipe Ex:" + ex.Message);
    }
}

我在客户端看不到可以定义或更改缓冲区大小的地方！

任何的想法？！

Answer 1

根本问题是你读得不够。如果PipeStream.IsMessageComplete为假，您需要重复读取操作，并继续这样做直到它返回真 - 这告诉您整个消息已被读取。根据您的解串器，您可能需要将数据存储在您自己的缓冲区中，或者创建一些包装流来为您处理。

一个简单的例子，说明这如何适用于简单的字符串反序列化：

void Main()
{
  var serverTask = Task.Run(() => Server()); // Just to keep this simple and stupid

  using (var client = new NamedPipeClientStream(".", "Pipe", PipeDirection.InOut))
  {
    client.Connect();
    client.ReadMode = PipeTransmissionMode.Message;

    var buffer = new byte[1024];
    var sb = new StringBuilder();

    int read;
    // Reading the stream as usual, but only the first message
    while ((read = client.Read(buffer, 0, buffer.Length)) > 0 && !client.IsMessageComplete)
    {
      sb.Append(Encoding.ASCII.GetString(buffer, 0, read));
    }

    Console.WriteLine(sb.ToString());
  }
}

void Server()
{
  using (var server
    = new NamedPipeServerStream("Pipe", PipeDirection.InOut, 1, 
                                PipeTransmissionMode.Message, PipeOptions.Asynchronous)) 
  {
    server.ReadMode = PipeTransmissionMode.Message;      
    server.WaitForConnection();

    // On the server side, we need to send it all as one byte[]
    var buffer = Encoding.ASCII.GetBytes(File.ReadAllText(@"D:\Data.txt"));
    server.Write(buffer, 0, buffer.Length); 
  }
}

顺便提一下 - 我可以轻松地一次读取或写入任意数量的数据 - 限制因素是我使用的缓冲区，而不是管道使用的缓冲区；尽管我使用的是本地命名管道，但 TCP 管道可能会有所不同（尽管它有点烦人 - 它应该从您那里抽象出来）。

编辑：

好的，现在终于明白你的问题是什么了。您不能使用StreamWriter- 当发送消息足够长时，它会导致Write对管道流进行多次调用，从而为您的数据生成多个单独的消息。如果要将整个消息作为单个消息，则必须使用单个Write调用。例如：

var data = Encoding.ASCII.GetBytes(yourJsonString);
Write(data, 0, data.Length);

1024 长的缓冲区是StreamWriters，它与命名管道无关。在任何网络场景中使用StreamWriter/StreamReader都是一个坏主意，即使在使用原始 TCP 流时也是如此。这不是它的设计目的。