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为false，则需要重复读取操作，并继续执行该操作，直到它返回true - 告诉您已读取整个消息。根据您的反序列化程序，您可能需要将数据存储在您自己的缓冲区中，或者创建一些包装器流来为您处理。

这可以用于简单的字符串反序列化的一个简单示例：

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

正如旁注 - 我可以轻松读取或写入我想要的数据 - 限制因素是缓冲区 I 使用，而不是管道使用的缓冲区;虽然我使用的是本地命名管道，但TCP管道可能有所不同（虽然它有点烦人 - 它应该被抽象出来）。

修改

好的，现在终于可以明白你的问题了。您无法使用StreamWriter - 在发送消息的时间足够长时，它会在管道流上产生多个Write调用，从而导致数据的多个单独消息。如果您希望将整个邮件作为单个邮件，则必须使用单个Write调用。例如：

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

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

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

1 个答案: