Estou trabalhando com c # e tendo problemas para entender como lerstdout de forma assíncrona a partir de um processo filho. O que eu quero fazer é criar um processo filho que execute um aplicativo e depois apresentar o que é recebido do stdout desse processo em uma caixa de texto. Preciso ver todos os caracteres de saída do processo filho imediatamente e não posso esperar a conclusão de uma linha; portanto, não acho que oProcess.OutputDataReceived evento se adapte ao meu propósito. Você pode me dizer uma maneira sensata de fazer isso?

Eu tentei ligarProcess.StandardOutput.BaseStream.BeginRead() e passando uma função de retorno de chamada para ela, mas nessa função de retorno de chamada, recebo uma exceção deProcess.StandardOutput.BaseStream.EndRead().

Meu código se parece com isso (o processo filho é um mecanismo de script - abreviado "SE") para verificar a funcionalidade de um dispositivo externo. Os scripts são executados em seqüência e cada script requer uma instância do aplicativo SE)

private bool startScript()
{
  // Starts the currently indexed script

  if (null != scriptList)
  {

    if (0 == scriptList.Count || scriptListIndexer == scriptList.Count)
    {
      // If indexer equals list count then there are no active scripts in
      // the list or the last active script in the list has just finished
      return false;                              // ## RETURN ##
    }
    if (ScriptExecutionState.RUNNING == scriptList[scriptListIndexer].executionState)
    {
      return false;                              // ## RETURN ##
    }

    if (0 == SE_Path.Length)
    {
      return false;                              // ## RETURN ##
    }

    SE_Process = new Process();
    SE_Process.StartInfo.FileName = SE_Path;
    SE_Process.StartInfo.CreateNoWindow = true;
    SE_Process.StartInfo.UseShellExecute = false;
    SE_Process.StartInfo.RedirectStandardError = true;
    SE_Process.StartInfo.RedirectStandardOutput = true;
    SE_Process.EnableRaisingEvents = true;
    SE_Process.StartInfo.Arguments = scriptList[scriptListIndexer].getParameterString();

    // Subscribe to process exit event
    SE_Process.Exited += new EventHandler(SE_Process_Exited);

    try
    {
      if (SE_Process.Start())
      {
        // Do stuff
      }
      else
      {
        // Do stuff
      }
    }
    catch (Exception exc)
    {
      // Do stuff
    }

    // Assign 'read_SE_StdOut()' as call-back for the event of stdout-data from SE
    SE_Process.StandardOutput.BaseStream.BeginRead(SE_StdOutBuffer, 0, SE_BUFFERSIZE, read_SE_StdOut, null);

    return true;                                       // ## RETURN ##

  }
  else
  {
    return false;                                      // ## RETURN ##
  }
}

private void read_SE_StdOut(IAsyncResult result)
{
  try
  {
    int bytesRead = SE_Process.StandardOutput.BaseStream.EndRead(result);  // <-- Throws exceptions

    if (0 != bytesRead)
    {
      // Write the received data in output textbox
      ...
    }

    // Reset the callback
    SE_Process.StandardOutput.BaseStream.BeginRead(SE_StdOutBuffer, 0, SE_BUFFERSIZE,     read_SE_StdOut, null);
  }
  catch (Exception exc)
  {
    // Do stuff
  }
}

void SE_Process_Exited(object sender, EventArgs e)
{

  // Keep track of whether or not the next script shall be started
  bool continueSession = false;

  switch (SE_Process.ExitCode)
  {
    case 0: // PASS
    {
      // Do stuff
    }

    ...

  }

  SE_Process.Dispose(); // TODO: Is it necessary to dispose of the process?

  if (continueSession)
  {
    ts_incrementScriptListIndexer();

    if (scriptListIndexer == scriptList.Count)
    {
      // Last script has finished, reset the indexer and re-enable
      // 'scriptListView'
      ...
    }
    else
    {
      if (!startScript())
      {
        // Do stuff
      }
    }
  }
  else
  {
    ts_resetScriptListIndexer();
    threadSafeEnableScriptListView();
  }
}

O que acontece é que, após a conclusão de um processo SE, recebo uma exceção do tipoInvalidOperationException isso diz

O StandardOut não foi redirecionado ou o processo ainda não foi iniciado.

da chamada paraSE_Process.StandardOutput.BaseStream.EndRead(). Eu não entendo o porquê porque configureiSE_Process.StartInfo.RedirectStandardOutput antes do início de cada novo processo. Parece-me que o fluxo stdout de um processo encerrado chama meuread_SE_StdOut() função após o processo ter sido descartado, isso é possível?

Obrigado pela leitura!