c# - 优雅地关闭命名管道并处理流

Question

我有一个双向命名管道。不过，我不确定如何优雅地关闭它-一旦我从客户端关闭了连接，如果服务器端尝试处置StreamReader和StreamWriter，则服务器端会引发异常。米使用。我目前正在抓住它，但这对我来说似乎是一项艰巨的工作。

服务器端代码：

Thread pipeServer = new Thread(ServerThread);
pipeServer.Start();

private void ServerThread(object data)
{
    int threadId = Thread.CurrentThread.ManagedThreadId;
    log.Debug("Spawned thread " + threadId);

    PipeSecurity ps = new PipeSecurity();
    SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
    ps.AddAccessRule(new PipeAccessRule(sid, PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow));
    ps.AddAccessRule(new PipeAccessRule(WindowsIdentity.GetCurrent().Owner, PipeAccessRights.FullControl, System.Security.AccessControl.AccessControlType.Allow));
    log.Debug("Pipe security settings set [Thread " + threadId + "]");

    NamedPipeServerStream pipeServer =
        new NamedPipeServerStream("RDPCommunicationPipe", PipeDirection.InOut, numThreads, PipeTransmissionMode.Message, PipeOptions.None, 0x1000, 0x1000, ps);

    log.Debug("Pipe Servers created");

    // Wait for a client to connect
    log.Info("Pipe created on thread " + threadId + ". Listening for client connection.");
    pipeServer.WaitForConnection();
    log.Debug("Pipe server connection established [Thread " + threadId + "]");

    Thread nextServer = new Thread(ServerThread);
    nextServer.Start();

    try
    {
        // Read the request from the client. Once the client has
        // written to the pipe its security token will be available.

        using (StreamReader sr = new StreamReader(pipeServer))
        {
            using (StreamWriter sw = new StreamWriter(pipeServer) { AutoFlush = true })
            {
                // Verify our identity to the connected client using a
                // string that the client anticipates.

                sw.WriteLine("I am the one true server!");

                log.Debug("[Thread " + threadId + "]" + sr.ReadLine());

                log.Info(string.Format("Client connected on thread {0}. Client ID: {1}", threadId, pipeServer.GetImpersonationUserName()));
                while (!sr.EndOfStream)
                {
                    log.Debug("[Thread " + threadId + "]" + sr.ReadLine());
                }
            }
        }
    }
    // Catch the IOException that is raised if the pipe is broken
    // or disconnected.
    catch (IOException e)
    {
        log.Error("ERROR: " + e);
    }
}

客户端代码：

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Starting...");
        var client = new NamedPipeClientStream(".", "RDPCommunicationPipe", PipeDirection.InOut);
        client.Connect();
        Console.WriteLine("Pipe connected successfully");

        using (StreamReader sr = new StreamReader(client))
        {
            using (StreamWriter sw = new StreamWriter(client) { AutoFlush = true })
            {
                string temp;
                do
                {
                    temp = sr.ReadLine();
                    Console.WriteLine(temp);
                } while (temp.Trim() != "I am the one true server!");

                sw.WriteLine("Message received and understood");
                while (!string.IsNullOrEmpty(temp = Console.ReadLine()))
                {
                    sw.WriteLine(temp);
                }
            }
        }
        client.Close();
    }
}

直到我在客户端应用程序中的空白行上按Enter键，它会终止并关闭客户端，它才能正常运行。然后，服务器应用程序到达StreamWriter System.IO.IOException: Pipe is broken.块的末尾时将引发 using。如何正确处理流处理程序？

（基于 here和 here找到的想法的代码。）

Answer 1

我目前正在抓住它，但是对我来说这似乎是一项艰巨的工作。


恕我直言，如果您想成为一个好邻居并处置自己拥有的StreamWriter对象并且仍然付出最小的努力，那将和您将获得的一样好。

就是说，在我看来，在这种特殊情况下，也可以将对Dispose()的调用注释掉（或者在您的情况下，不使用using语句），并加入另一条注释来说明这一点，在执行代码的顺序中，您知道调用将要执行的所有操作都将引发异常，因此进行该操作毫无意义。

当然，如果您只是不想处理StreamWriter，那么您将希望显式地处理管道流。您可能还希望使用具有StreamWriter参数的leaveOpen构造函数，并为该参数传递true，以此来证明您不希望StreamWriter拥有管道流对象的意图。

无论哪种方式，您都将最终对象留在终结器队列中，因为异常会绕过对GC.SuppressFinalize()的调用，（当然）也不会费心去调用Dispose()。只要您不处理大量情况（即许多此类对象），那可能就很好。但这当然不是理想的。

不幸的是，命名管道本身并不具有提供套接字所提供的“优雅关闭”的语义。也就是说，端点指示完成写入的唯一方法是断开连接（对于服务器管道）或关闭（对于服务器或客户端管道）。这两个选项都不会使管道可供读取，因此在管道上实现优雅的关闭需要在应用程序协议内部进行握手，而不是依赖I / O对象。

除了这种不便之处（我承认，这实际上与您的问题没有直接关系），PipeStream.Flush()的实现还会检查管道是否可写。即使它无意写任何东西！这是我觉得很烦人的最后一部分，当然直接导致了您要问的问题。对于我来说，.NET Framework中的代码在那些异常带来的麻烦多于弊端的情况下，会抛出异常抛出异常，这似乎是不合理的。

综上所述，您还有其他选择：


子类化NamedPipeServerStream和NamedPipeClientStream类型，并覆盖Flush()方法，使其真正不执行任何操作。或更确切地说，如果您可以这样做，那将是很好。但是这些类型是sealed，所以不能。
除了子类化这些类型之外，还可以将它们包装在自己的Stream实现中。这要麻烦得多，尤其是因为您可能想覆盖所有异步成员，至少在打算在任何对I / O性能感兴趣的情况下都使用这些对象的情况下更是如此。
使用单独的单向管道进行读取和写入。在此实现中，您可以关闭StreamWriter本身作为关闭连接的一种方式，这将导致事物顺序正确（即，刷新发生在关闭管道之前）。这也解决了正常的关闭问题，因为每个连接有两个管道，您可以具有与套接字相同的基本“半关闭”语义。当然，由于难以确定哪些对管道连接相互连接，因此该选项变得非常复杂。


这两种（即第二和第三种，即实际上可行的）都有明显的缺点。由于必须进行所有重复的代码，因此必须拥有自己的Stream类很麻烦。而且，将管道对象数量加倍似乎是解决异常的一种好方法（但它可能是一种可接受的且理想的实现，用于支持优美的关闭语义，并且具有消除StreamWriter.Dispose()引发异常问题的令人愉快的副作用） 。

请注意，在大量情况下（但是，为什么要使用管道？😊），频繁抛出和捕获异常可能是个问题（它们很昂贵）。因此，在那种情况下，这两个替代选择中的一个或另一个可能比捕获异常并且不费心关闭/处置您的StreamWriter（两者都会增加效率低下，从而干扰大批量情况）更可取。 ）。