Warum ist die streamreader-süchtig bis zu networkstream null zurückgeben auf ReadLine()?

Im code unten habe ich einen StreamReader Lesen aus einem Netzwerk-stream. Dieser code normalerweise läuft gut für Tage. Ich lief in ein problem, wo plötzlich StreamReader.ReadLine() gestartet wird null zurückgeben.

Laut Microsoft-Dokumentation StreamReader.ReadLine() gibt null zurück, wenn es das Ende erreicht hat von der input-stream. Das ergibt keinen Sinn für mich, wenn der zugrunde liegende stream ist ein NetworkStream. Sollte nicht ReadLine() nur blockieren, bis die Netzwerk-stream-Daten empfängt?

Dies ist das erste mal, ich lief in dieses problem, und ich habe nicht in der Lage, es zu duplizieren. Was könnte dies verursachen?

Kontext: erhält die Anwendung der CDR-Datensätze aus einem Telefon-switch. Der Telefon-switch verbindet, um die Anwendung und sendet nur alte text-Datensätze. Nach dem Wechsel verbindet es bleibt verbunden und halten senden von Datensätzen für die Ewigkeit, es sei denn, etwas kaputt.

    private void ProcessClient(TcpClient client)
    {
        try
        {
            using (NetworkStream stream = client.GetStream())
            {
                using (StreamReader reader = new StreamReader(stream))
                {
                    //continue processing while service is on
                    while (m_RunService & client.Connected)
                    {

                        string curLine = reader.ReadLine();

                        //code here does stuff to string
                        //will catch any exceptions that have to do with 
                        //processing the string
                    }
                }
            }
        }
        catch (Exception ex)
        {
            //write to log
        }
    }

Hier ist der code, die beginnt, dem Hörer:

    private void Listen()
    {
        try
        {
            while (m_RunService)
            {
                try
                {
                    m_TcpClient = m_TcpListener.AcceptTcpClient();

                    //run on same thread, should only ever be 1 cnx at a time
                    ProcessClient(m_TcpClient);
                }
                catch (Exception ex)
                {
                    //write to log
                }
                finally
                {
                    m_TcpClient.Close();
                }
            }
        }
        finally
        {
            m_TcpListener.Stop();
        }        
    }