Process.ExitCode Propriété

Définition

Obtient la valeur spécifiée par le processus associé au moment où il s'est terminé.Gets the value that the associated process specified when it terminated.

public:
 property int ExitCode { int get(); };
[System.ComponentModel.Browsable(false)]
public int ExitCode { get; }
member this.ExitCode : int
Public ReadOnly Property ExitCode As Integer

Valeur de propriété

Code spécifié par le processus associé une fois celui-ci terminé.The code that the associated process specified when it terminated.

Attributs

Exceptions

Le processus ne s’est pas fermé.The process has not exited.

- ou --or- Le processus Handle n’est pas valide.The process Handle is not valid.

Vous tentez d’accéder à la propriété ExitCode d’un processus en cours d’exécution sur un ordinateur distant.You are trying to access the ExitCode property for a process that is running on a remote computer. Cette propriété est disponible uniquement pour les processus en cours d’exécution sur l’ordinateur local.This property is available only for processes that are running on the local computer.

Exemples

L’exemple suivant démarre une instance du bloc-notes.The following example starts an instance of Notepad. L’exemple récupère ensuite et affiche diverses propriétés du processus associé.The example then retrieves and displays various properties of the associated process. L’exemple détecte à quel moment le processus se termine et affiche le code de sortie du processus.The example detects when the process exits, and displays the process's exit code.

#using <system.dll>

using namespace System;
using namespace System::Diagnostics;
int main()
{
   
   // Define variables to track the peak
   // memory usage of the process.
   _int64 peakPagedMem = 0,peakWorkingSet = 0,peakVirtualMem = 0;
   Process^ myProcess = nullptr;
   try
   {
      
      // Start the process.
      myProcess = Process::Start( "NotePad.exe" );
      
      // Display the process statistics until
      // the user closes the program.
      do
      {
         if (  !myProcess->HasExited )
         {
            
            // Refresh the current process property values.
            myProcess->Refresh();
            Console::WriteLine();
            
            // Display current process statistics.
            Console::WriteLine( "{0} -", myProcess );
            Console::WriteLine( "-------------------------------------" );
            Console::WriteLine( "  physical memory usage: {0}", myProcess->WorkingSet64 );
            Console::WriteLine( "  base priority: {0}", myProcess->BasePriority );
            Console::WriteLine( "  priority class: {0}", myProcess->PriorityClass );
            Console::WriteLine( "  user processor time: {0}", myProcess->UserProcessorTime );
            Console::WriteLine( "  privileged processor time: {0}", myProcess->PrivilegedProcessorTime );
            Console::WriteLine( "  total processor time: {0}", myProcess->TotalProcessorTime );
            Console::WriteLine("  PagedSystemMemorySize64: {0}", myProcess->PagedSystemMemorySize64);
            Console::WriteLine("  PagedMemorySize64: {0}", myProcess->PagedMemorySize64);
            
            // Update the values for the overall peak memory statistics.
            peakPagedMem = myProcess->PeakPagedMemorySize64;
            peakVirtualMem = myProcess->PeakVirtualMemorySize64;
            peakWorkingSet = myProcess->PeakWorkingSet64;
            if ( myProcess->Responding )
            {
               Console::WriteLine( "Status = Running" );
            }
            else
            {
               Console::WriteLine( "Status = Not Responding" );
            }
         }
      }
      while (  !myProcess->WaitForExit( 1000 ) );
      Console::WriteLine();
      Console::WriteLine( "Process exit code: {0}", myProcess->ExitCode );
      
      // Display peak memory statistics for the process.
      Console::WriteLine( "Peak physical memory usage of the process: {0}", peakWorkingSet );
      Console::WriteLine( "Peak paged memory usage of the process: {0}", peakPagedMem );
      Console::WriteLine( "Peak virtual memory usage of the process: {0}", peakVirtualMem );
   }
   finally
   {
      if ( myProcess != nullptr )
      {
         myProcess->Close();
      }
   }

}
using System;
using System.Diagnostics;

namespace ProcessSample
{
    class ProcessMonitorSample
    {
        public static void Main()
        {
            // Define variables to track the peak
            // memory usage of the process.
            long peakPagedMem   = 0,
                 peakWorkingSet = 0,
                 peakVirtualMem = 0;

            // Start the process.
            using (Process myProcess = Process.Start("NotePad.exe"))
            {
                // Display the process statistics until
                // the user closes the program.
                do
                {
                    if (!myProcess.HasExited)
                    {
                        // Refresh the current process property values.
                        myProcess.Refresh();

                        Console.WriteLine();

                        // Display current process statistics.

                        Console.WriteLine($"{myProcess} -");
                        Console.WriteLine("-------------------------------------");

                        Console.WriteLine($"  Physical memory usage     : {myProcess.WorkingSet64}");
                        Console.WriteLine($"  Base priority             : {myProcess.BasePriority}");
                        Console.WriteLine($"  Priority class            : {myProcess.PriorityClass}");
                        Console.WriteLine($"  User processor time       : {myProcess.UserProcessorTime}");
                        Console.WriteLine($"  Privileged processor time : {myProcess.PrivilegedProcessorTime}");
                        Console.WriteLine($"  Total processor time      : {myProcess.TotalProcessorTime}");
                        Console.WriteLine($"  Paged system memory size  : {myProcess.PagedSystemMemorySize64}");
                        Console.WriteLine($"  Paged memory size         : {myProcess.PagedMemorySize64}");

                        // Update the values for the overall peak memory statistics.
                        peakPagedMem   = myProcess.PeakPagedMemorySize64;
                        peakVirtualMem = myProcess.PeakVirtualMemorySize64;
                        peakWorkingSet = myProcess.PeakWorkingSet64;

                        if (myProcess.Responding)
                        {
                            Console.WriteLine("Status = Running");
                        }
                        else
                        {
                            Console.WriteLine("Status = Not Responding");
                        }
                    }
                }
                while (!myProcess.WaitForExit(1000));


                Console.WriteLine();
                Console.WriteLine($"  Process exit code          : {myProcess.ExitCode}");

                // Display peak memory statistics for the process.
                Console.WriteLine($"  Peak physical memory usage : {peakWorkingSet}");
                Console.WriteLine($"  Peak paged memory usage    : {peakPagedMem}");
                Console.WriteLine($"  Peak virtual memory usage  : {peakVirtualMem}");
            }
        }
    }
}
Imports System.Diagnostics

Namespace ProcessSample
    Class ProcessMonitorSample

        Public Shared Sub Main()

            ' Define variables to track the peak
            ' memory usage of the process.
            Dim peakPagedMem As Long = 0
            Dim peakWorkingSet As Long = 0
            Dim peakVirtualMem As Long = 0

            ' Start the process.
            Using myProcess = Process.Start("NotePad.exe")

                ' Display process statistics until
                ' the user closes the program.
                Do

                    If Not myProcess.HasExited Then

                        ' Refresh the current process property values.
                        myProcess.Refresh()

                        Console.WriteLine()

                        ' Display current process statistics.

                        Console.WriteLine($"{myProcess} -")
                        Console.WriteLine("-------------------------------------")

                        Console.WriteLine($"  Physical memory usage     : {myProcess.WorkingSet64}")
                        Console.WriteLine($"  Base priority             : {myProcess.BasePriority}")
                        Console.WriteLine($"  Priority class            : {myProcess.PriorityClass}")
                        Console.WriteLine($"  User processor time       : {myProcess.UserProcessorTime}")
                        Console.WriteLine($"  Privileged processor time : {myProcess.PrivilegedProcessorTime}")
                        Console.WriteLine($"  Total processor time      : {myProcess.TotalProcessorTime}")
                        Console.WriteLine($"  Paged system memory size  : {myProcess.PagedSystemMemorySize64}")
                        Console.WriteLine($"  Paged memory size         : {myProcess.PagedMemorySize64}")

                        ' Update the values for the overall peak memory statistics.
                        peakPagedMem = myProcess.PeakPagedMemorySize64
                        peakVirtualMem = myProcess.PeakVirtualMemorySize64
                        peakWorkingSet = myProcess.PeakWorkingSet64

                        If myProcess.Responding Then
                            Console.WriteLine("Status = Running")
                        Else
                            Console.WriteLine("Status = Not Responding")
                        End If
                    End If
                Loop While Not myProcess.WaitForExit(1000)

                Console.WriteLine()
                Console.WriteLine($"  Process exit code                         : {myProcess.ExitCode}")

                ' Display peak memory statistics for the process.
                Console.WriteLine($"  Peak physical memory usage of the process : {peakWorkingSet}")
                Console.WriteLine($"  Peak paged memory usage of the process    : {peakPagedMem}")
                Console.WriteLine($"  Peak virtual memory usage of the process  : {peakVirtualMem}")
            End Using
        End Sub
    End Class
End Namespace

Remarques

Utilisez ExitCode pour connaître l’état retourné par le processus système lorsqu’il s’est terminé.Use ExitCode to get the status that the system process returned when it exited. Vous pouvez utiliser le code de sortie comme une valeur de retour de type entier d’une procédure main().You can use the exit code much like an integer return value from a main() procedure.

La valeur ExitCode pour un processus reflète la Convention spécifique implémentée par le développeur de l’application pour ce processus.The ExitCode value for a process reflects the specific convention implemented by the application developer for that process. Si vous utilisez la valeur de code de sortie pour prendre des décisions dans votre code, assurez-vous de connaître la Convention du code de sortie utilisée par le processus d’application.If you use the exit code value to make decisions in your code, be sure that you know the exit code convention used by the application process.

Les développeurs indiquent généralement une sortie réussie par une ExitCode valeur de zéro et désignent des erreurs par des valeurs autres que zéro que la méthode appelante peut utiliser pour identifier la cause d’un arrêt anormal du processus.Developers usually indicate a successful exit by an ExitCode value of zero, and designate errors by nonzero values that the calling method can use to identify the cause of an abnormal process termination. Il n’est pas nécessaire de suivre ces instructions, mais il s’agit de la Convention.It is not necessary to follow these guidelines, but they are the convention.

Si vous essayez d’accéder au ExitCode avant que le processus ne s’arrête, la tentative lève une exception.If you try to get the ExitCode before the process has exited, the attempt throws an exception. Examinez d’abord la propriété HasExited pour vérifier si le processus associé s’est terminé.Examine the HasExited property first to verify whether the associated process has terminated.

Notes

Quand la sortie standard a été redirigée vers des gestionnaires d’événements asynchrones, il est possible que le traitement de la sortie ne soit pas terminé quand HasExited retourne true.When standard output has been redirected to asynchronous event handlers, it is possible that output processing will not have completed when HasExited returns true. Pour vous assurer que la gestion des événements asynchrones est terminée, appelez la surcharge WaitForExit() qui n’accepte aucun paramètre avant de vérifier HasExited.To ensure that asynchronous event handling has been completed, call the WaitForExit() overload that takes no parameter before checking HasExited.

Vous pouvez utiliser la méthode CloseMainWindow ou Kill pour provoquer la fermeture d’un processus associé.You can use the CloseMainWindow or the Kill method to cause an associated process to exit.

Il existe deux façons de recevoir une notification lorsque le processus associé se termine : de façon synchrone et asynchrone.There are two ways of being notified when the associated process exits: synchronously and asynchronously. La notification synchrone s’appuie sur l’appel de la méthode WaitForExit pour suspendre le traitement de votre application jusqu’à ce que le composant associé se termine.Synchronous notification relies on calling the WaitForExit method to pause the processing of your application until the associated component exits. La notification asynchrone s’appuie sur l’événement Exited.Asynchronous notification relies on the Exited event. Lors de l’utilisation d’une notification asynchrone, EnableRaisingEvents doit avoir la valeur true pour que le composant Process reçoit une notification indiquant que le processus s’est terminé.When using asynchronous notification, EnableRaisingEvents must be set to true for the Process component to receive notification that the process has exited.

Sécurité

LinkDemand
pour une confiance totale pour l’appelant immédiat.for full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code d'un niveau de confiance partiel.This member cannot be used by partially trusted code.

S’applique à

Voir aussi