Cette documentation est archivée et n’est pas conservée.

Process.CancelOutputRead, méthode

Mise à jour : novembre 2007

Annule l'opération de lecture asynchrone sur le flux StandardOutput redirigé d'une application.

Espace de noms :  System.Diagnostics
Assembly :  System (dans System.dll)

[ComVisibleAttribute(false)]
public void CancelOutputRead()
/** @attribute ComVisibleAttribute(false) */
public void CancelOutputRead()
public function CancelOutputRead()

ExceptionCondition
InvalidOperationException

Le flux StandardOutput n'est pas activé pour les opérations de lecture asynchrones.

BeginOutputReadLine démarre une opération de lecture asynchrone sur le flux StandardOutput. CancelOutputRead termine l'opération de lecture asynchrone.

Après avoir annulé, vous pouvez continuer les opérations de lecture asynchrones en appelant de nouveau BeginOutputReadLine.

Lorsque vous appelez CancelOutputRead, toutes les opérations en cours de lecture pour StandardOutput sont terminées puis le gestionnaire d'événements est désactivé. Toute sortie redirigée ultérieure vers StandardOutput est enregistrée dans une mémoire tampon. Si vous réactivez le gestionnaire d'événements avec un appel à BeginOutputReadLine, la sortie enregistrée est envoyée au gestionnaire d'événements et les opérations de lecture asynchrones continuent. Si vous souhaitez modifier le gestionnaire d'événements avant de reprendre des opérations de lecture asynchrones, vous devez supprimer le gestionnaire d'événements existant avant d'ajouter le nouveau gestionnaire d'événements :

    // At this point the DataReceivedEventHandler(OutputHandler1) 
    // has executed a CancelOutputRead.

    // Remove the prior event handler.
    process.OutputDataReceived -= 
        new DataReceivedEventHandler(OutputHandler1);

    // Register a new event handler.
    process.OutputDataReceived += 
        new DataReceivedEventHandler(OutputHandler2);

    // Call the corresponding BeginOutputReadLine.
    process.BeginOutputReadLine();
Remarque :

Vous ne pouvez pas associer des opérations de lecture asynchrones et synchrones sur le flux redirigé StandardOutput. Une fois que le flux redirigé d'un Process est ouvert en mode asynchrone ou synchrone, toutes les opérations de lecture supplémentaires sur ce flux doivent avoir lieu dans le même mode. Si vous annulez une opération de lecture asynchrone sur StandardOutput puis devez lire le flux de nouveau, vous devez utiliser BeginOutputReadLine pour continuer les opérations de lecture asynchrones. Ne suivez pas CancelOutputRead par un appel aux méthodes de lecture synchrones de StandardOutput telles que Read, ReadLine ou ReadToEnd.

L'exemple suivant démarre la commande nmake avec des arguments fournis par l'utilisateur. Les flux de sortie et d'erreurs sont lus de façon asynchrone ; les lignes de texte réunies sont affichées dans la console et sont également écrits dans un fichier journal. Si le résultat de la commande dépasse un nombre spécifié de lignes, les opérations de lecture asynchrones sont annulées.

namespace ProcessAsyncStreamSamples
{
    class ProcessNMakeStreamRedirection
    {
        // Define static variables shared by class methods.
        private static StreamWriter buildLogStream =null;
        private static Mutex logMutex = new Mutex();
        private static int maxLogLines = 25;
        private static int currentLogLines = 0;

        public static void RedirectNMakeCommandStreams()
        {
            String nmakeArguments = null;
            Process nmakeProcess;

            // Get the input nmake command-line arguments.
            Console.WriteLine("Enter the NMake command line arguments " +
                "(@commandfile or /f makefile, etc):");
            String inputText = Console.ReadLine();
            if (!String.IsNullOrEmpty(inputText))
            {
                nmakeArguments = inputText;
            }

            Console.WriteLine("Enter max line limit for log file (default is 25):");
            inputText = Console.ReadLine();
            if (!String.IsNullOrEmpty(inputText))
            {
                if (!Int32.TryParse(inputText, out maxLogLines))
                {
                    maxLogLines = 25;
                }
            }
            Console.WriteLine("Output beyond {0} lines will be ignored.",
                maxLogLines);

            // Initialize the process and its StartInfo properties.
            nmakeProcess = new Process();
            nmakeProcess.StartInfo.FileName = "NMake.exe";

            // Build the nmake command argument list.
            if (!String.IsNullOrEmpty(nmakeArguments))
            {
                nmakeProcess.StartInfo.Arguments = nmakeArguments;
            }

            // Set UseShellExecute to false for redirection.
            nmakeProcess.StartInfo.UseShellExecute = false;

            // Redirect the standard output of the nmake command.  
            // Read the stream asynchronously using an event handler.
            nmakeProcess.StartInfo.RedirectStandardOutput = true;
            nmakeProcess.OutputDataReceived += new DataReceivedEventHandler(NMakeOutputDataHandler);

            // Redirect the error output of the nmake command. 
            nmakeProcess.StartInfo.RedirectStandardError = true;
            nmakeProcess.ErrorDataReceived += new DataReceivedEventHandler(NMakeErrorDataHandler);

            logMutex.WaitOne();

            currentLogLines = 0;

            // Write a header to the log file.
            const String buildLogFile = "NmakeCmd.Txt";
            try 
            {
                buildLogStream = new StreamWriter(buildLogFile, true);
            }
            catch (Exception e)
            {
                Console.WriteLine("Could not open output file {0}", buildLogFile);
                Console.WriteLine("Exception = {0}", e.ToString());
                Console.WriteLine(e.Message);

                buildLogStream = null;
            }

            if (buildLogStream != null)
            {   
                Console.WriteLine("Nmake output logged to {0}", 
                    buildLogFile);

                buildLogStream.WriteLine();
                buildLogStream.WriteLine(DateTime.Now.ToString());
                if (!String.IsNullOrEmpty(nmakeArguments))
                {
                    buildLogStream.Write("Command line = NMake {0}",
                        nmakeArguments);
                }
                else 
                {
                    buildLogStream.Write("Command line = Nmake");
                }
                buildLogStream.WriteLine();
                buildLogStream.Flush();

                logMutex.ReleaseMutex();

                // Start the process.
                Console.WriteLine();
                Console.WriteLine("\nStarting Nmake command...");
                Console.WriteLine();
                nmakeProcess.Start();

                // Start the asynchronous read of the error stream.
                nmakeProcess.BeginErrorReadLine();

                // Start the asynchronous read of the output stream.
                nmakeProcess.BeginOutputReadLine();

                // Let the nmake command run, collecting the output.
                nmakeProcess.WaitForExit();

                nmakeProcess.Close();
                buildLogStream.Close();
            }
        }

        private static void NMakeOutputDataHandler(object sendingProcess, 
            DataReceivedEventArgs outLine)
        {
            // Collect the output, displaying it to the screen and 
            // logging it to the output file.  Cancel the read
            // operation when the maximum line limit is reached.

            if (!String.IsNullOrEmpty(outLine.Data))
            {
                logMutex.WaitOne();

                currentLogLines++;
                if (currentLogLines > maxLogLines)
                {
                    // Display the line to the console.
                    // Skip writing the line to the log file.
                    Console.WriteLine("StdOut: {0}", outLine.Data);
                }
                else if (currentLogLines == maxLogLines)
                {
                    LogToFile("StdOut", "<Max build log limit reached!>", 
                        true);

                    // Stop reading the output streams.
                    Process p = sendingProcess as Process;
                    if (p != null)
                    {
                        p.CancelOutputRead();
                        p.CancelErrorRead();
                    }
                }
                else 
                {
                    // Write the line to the log file.
                    LogToFile("StdOut", outLine.Data, true);
                }
                logMutex.ReleaseMutex();
            }
        }

        private static void NMakeErrorDataHandler(object sendingProcess, 
            DataReceivedEventArgs errLine)
        {
            // Collect error output, displaying it to the screen and 
            // logging it to the output file.  Cancel the error output
            // read operation when the maximum line limit is reached.

            if (!String.IsNullOrEmpty(errLine.Data))
            {
                logMutex.WaitOne();

                currentLogLines++;
                if (currentLogLines > maxLogLines)
                {
                    // Display the error line to the console.
                    // Skip writing the line to the log file.
                    Console.WriteLine("StdErr: {0}", errLine.Data);
                }
                else if (currentLogLines == maxLogLines)
                {
                    LogToFile("StdErr", "<Max build log limit reached!>", 
                        true);

                    // Stop reading the output streams
                    Process p = sendingProcess as Process;
                    if (p != null)
                    {
                        p.CancelErrorRead();
                        p.CancelOutputRead();

                    }
                }
                else 
                {
                    // Write the line to the log file.
                    LogToFile("StdErr", errLine.Data, true);
                }

                logMutex.ReleaseMutex();
            }
        }

        private static void LogToFile(String logPrefix, 
            String logText, bool echoToConsole)
        {
            // Write the specified line to the log file stream.
            StringBuilder logString = new StringBuilder();

            if (!String.IsNullOrEmpty(logPrefix))
            {
                logString.AppendFormat("{0}> ", logPrefix);
            }

            if (!String.IsNullOrEmpty(logText))
            {
                logString.Append(logText); 
            }

            if (buildLogStream != null)
            {
                buildLogStream.WriteLine("[{0}] {1}",
                    DateTime.Now.ToString(), logString.ToString());
                buildLogStream.Flush();
            }

            if (echoToConsole)
            {
                Console.WriteLine(logString.ToString());
            }
        }
    }
} 


  • SecurityAction.LinkDemand 

    pour une confiance totale accordée à l'appelant immédiat. Ce membre ne peut pas être utilisé par du code d'un niveau de confiance partiel.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professionnel Édition x64, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

.NET Framework

Pris en charge dans : 3.5, 3.0, 2.0
Afficher: