c# - C#: 非同期 NamedPipeServerStream パイプが閉じられているという例外

Question

同じテーマに関する以前の質問: C#: Asynchronous NamedPipeServerStream の理解今、私は次のことを持っています:

private void StartListeningPipes()
{
    try
    {
        isPipeWorking = true;
                namedPipeServerStream = new NamedPipeServerStream(PIPENAME, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, BUFFERSIZE, BUFFERSIZE);
                Console.Write("Waiting for client connection...");
                while(isPipeWorking)
                {
            IAsyncResult asyncResult = namedPipeServerStream.BeginWaitForConnection(this.WaitForConnectionAsyncCallback, null);
                        Thread.Sleep(3*1000);
                }
        }
        //// Catch the IOException that is raised if the pipe is broken or disconnected.
        catch (IOException e)
        {
        Console.WriteLine("IOException: {0}. Restart pipe server...", e.Message);
                StopListeningPipes();
                StartListeningPipes();
        }
        //// Catch ObjectDisposedException if server was stopped. Then do nothing.
        catch (ObjectDisposedException)
        {
        }
}

private void WaitForConnectionAsyncCallback(IAsyncResult result)
{
    try
    {
        namedPipeServerStream.EndWaitForConnection(result);
        Console.WriteLine("Client connected.");
        namedPipeServerStream.WaitForPipeDrain();
                byte[] buff = new byte[BUFFERSIZE];
                namedPipeServerStream.Read(buff, 0, BUFFERSIZE);
                string recStr = TrimNulls(buff);
                Array.Clear(buff, 0, buff.Length);
                Console.WriteLine();
                Console.WriteLine("'"+recStr+"'");
    }
    catch (Exception e)
    {
        Console.WriteLine("Error: " + e.Message);            
        }
}

しかし、私は得ています

The pipe is being closed Exceptionクライアントからメッセージを受け取るたびに

なんで？

私の顧客：

 using (NamedPipeClientStream pipeStream = new NamedPipeClientStream(General.PIPENAME))
{
    try
        {
        byte[] bytes = General.Iso88591Encoding.GetBytes(sendingMessage);
                pipeStream.Write(bytes, 0, bytes.Length);
                pipeStream.Flush();
                pipeStream.WaitForPipeDrain();
        }
        catch (TimeoutException)
        {
        Console.WriteLine("Timeout error!");
        }
    catch (Exception e)
        {
        Console.WriteLine(string.Format("Error! ", e.Message));
        }
}

現時点での最終的なコードは次のとおりです。

/// <summary>
        /// Create new NamedPipeServerStream for listening to pipe client connection
        /// </summary>
        private void ListenForPipeClients()
        {
            if (!this.isListeningToClients)
                return;

            try
            {
                PipeSecurity ps = new PipeSecurity();
                PipeAccessRule par = new PipeAccessRule("Everyone", PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow);
                ps.AddAccessRule(par);
                pipeClientConnection = new NamedPipeServerStream(General.PIPENAME, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, General.BUFFERSIZE, General.BUFFERSIZE, ps);
                Console.Write("Waiting for client connection...");
                /*namedPipeServerStream.WaitForConnection();
                OnPipeConnected(namedPipeServerStream);*/
                IAsyncResult result = pipeClientConnection.BeginWaitForConnection(OnPipeConnected, pipeClientConnection);
            }
            catch (ObjectDisposedException)
            {
                //// Catch ObjectDisposedException if server was stopped. Then do nothing.
            }
            catch (Exception e)
            {
                Console.WriteLine("Error occures: {0}. Restart pipe server...", e.Message);
                this.logger.Add(LogLevel.Warning, string.Format("Error occures: {0}. Restart pipe server...", e.Message));
                ListenForPipeClients();
            }
        }

        /// <summary>
        /// Async callback on client connected action
        /// </summary>
        /// <param name="asyncResult">Async result</param>
        private void OnPipeConnected(IAsyncResult asyncResult)
        {
            using (var conn = (NamedPipeServerStream)asyncResult.AsyncState)
            {
                try
                {
                    conn.EndWaitForConnection(asyncResult);
                    Console.WriteLine("Client connected.");
                    PipeClientConnection clientConnection = new PipeClientConnection(conn, notifierSenderCache, defaultStorageTime);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                    this.logger.Add(LogLevel.Warning, e.Message);
                }
            }

            ListenForPipeClients();
        }

score 9 · Accepted Answer

NamedPipeServerStreamクライアントごとに個別に必要なようです。（これを発見したのは私ではないことに注意してください。他の回答を参照してください。）サーバー側の作業は次のようになると思います（ドラフトコード）：

while(this.isServerRunning)
{
     var pipeClientConnection = new NamedPipeServerStream(...);

     try
     {
         pipeClientConnection.WaitForConnection();
     }
     catch(...)
     {
         ...
         continue;
     }

     ThreadPool.QueueUserWorkItem(state =>
          {
               // we need a separate variable here, so as not to make the lambda capture the pipeClientConnection variable, which is not recommended in multi-threaded scenarios
               using(var pipeClientConn = (NamedPipeServerStream)state)
               {
                    // do stuff
                    ...
               }
          }, pipeClientConnection);
}

補足として、質問へのコメントで指摘されているようBeginWaitForConnectionに、ループで呼び出して 3 秒ごとに新しい非同期呼び出しを開始することでメモリを浪費しています (これがメモリを無駄にしない唯一のケースは、新しい接続は3秒未満の間隔で行われますが、これを確実に知ることができるとは思えません)。ご覧のとおり、最後の呼び出しがまだ保留中か完了しているかに関係なく、基本的に 3 秒ごとに新しい非同期呼び出しを開始しています。NamedPipeServerStreamさらに、繰り返しになりますが、クライアントごとに個別に必要であることは考慮されていません。

この問題を解決するには、ループを排除し、コールバックメソッドを使用して BeginWaitForConnection 呼び出しを「チェーン」する必要があります。これは、.NET を使用している場合に非同期 I/O でよく見られる同様のパターンです。ドラフトコード:

private void StartListeningPipes()
{
    if(!this.isServerRunning)
    {
        return;
    }

    var pipeClientConnection = new NamedPipeServerStream(...);

    try
    {
        pipeClientConnection.BeginWaitForConnection(asyncResult =>
            {
                // note that the body of the lambda is not part of the outer try... catch block!
                using(var conn = (NamedPipeServerStream)asyncResult.AsyncState)
                {
                    try
                    {
                        conn.EndWaitForConnection(asyncResult);
                    }
                    catch(...)
                    {
                        ...
                    }

                    // we have a connection established, time to wait for new ones while this thread does its business with the client
                    // this may look like a recursive call, but it is not: remember, we're in a lambda expression
                    // if this bothers you, just export the lambda into a named private method, like you did in your question
                    StartListeningPipes();

                    // do business with the client
                    conn.WaitForPipeDrain();
                    ...
                }
            }, pipeClientConnection);
    }
    catch(...)
    {
        ...
    }
}

制御フローは次のようになります。

[メインスレッド] StartListeningPipes(): NamedPipeServerStream を作成し、BeginWaitForConnection() を開始しました
[スレッドプールスレッド 1] クライアント #1 接続、BeginWaitForConnection() コールバック: EndWaitForConnection() その後 StartListeningPipes()
[スレッドプールスレッド 1] StartListeningPipes(): 新しい NamedPipeServerStream、BeginWaitForConnection() 呼び出しを作成しました
[スレッドプールスレッド 1] BeginWaitForConnection() コールバックに戻る: 接続されたクライアントとのやり取りに取り掛かる (#1)
[スレッドプールスレッド 2] クライアント #2 接続、BeginWaitForConnection() コールバック: ...
...

これは、ブロッキング I/O を使用するよりもはるかに難しいと思います - 実際、私はそれが正しいかどうか確信が持てません。間違いがあれば指摘してください - また、はるかに混乱します。

どちらの例でもサーバーを一時停止するには、明らかにthis.isServerRunningフラグをに設定しfalseます。

score 2 · Accepted Answer

Ok。私を馬鹿にした。クライアントごとに 1 つの NamedPipeServerStream が必要です。したがって、非同期操作が完了した場合は、NamedPipeServerStream を再作成する必要があります。このC# のマルチスレッド NamePipeServer に感謝します

次のようにする必要があります。

while(isPipeWorking)
            {
                IAsyncResult asyncResult = namedPipeServerStream.BeginWaitForConnection(this.WaitForConnectionAsyncCallback, null);
                Thread.Sleep(3*1000);
                if (asyncResult.IsCompleted)
                {
                    RestartPipeServer();
                    break;
                }
            }

c# - C#: 非同期 NamedPipeServerStream パイプが閉じられているという例外

2 に答える 2

Related

Reference