Process.ExitCode Eigenschaft

Definition

Ruft den Wert ab, der vom zugeordneten Prozess beim Beenden angegeben wurde.Gets the value that the associated process specified when it terminated.

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

Eigenschaftswert

Int32

Der Code, der vom zugeordneten Prozess beim Beenden angegeben wurde.The code that the associated process specified when it terminated.

Attribute

Ausnahmen

Der Prozess wurde nicht beendet.The process has not exited.

- oder --or- Der Prozess Handle ist ungültig.The process Handle is not valid.

Sie versuchen, auf die ExitCode-Eigenschaft für einen Prozess zuzugreifen, der auf einem Remotecomputer ausgeführt wird.You are trying to access the ExitCode property for a process that is running on a remote computer. Diese Eigenschaft ist nur für Prozesse verfügbar, die auf dem lokalen Computer ausgeführt werden.This property is available only for processes that are running on the local computer.

Beispiele

Im folgenden Beispiel wird eine Instanz von Editor gestartet.The following example starts an instance of Notepad. Im Beispiel werden dann die verschiedenen Eigenschaften des zugeordneten Prozesses abgerufen und angezeigt.The example then retrieves and displays various properties of the associated process. Das Beispiel erkennt, wenn der Prozess beendet wird, und zeigt den Exitcode des Prozesses an.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

Hinweise

Verwenden ExitCode Sie, um den Status zu erhalten, den der System Prozess beim verlassen zurückgegeben hat.Use ExitCode to get the status that the system process returned when it exited. Sie können den Exitcode ähnlich wie ein ganzzahliger Rückgabewert aus einer main() Prozedur verwenden.You can use the exit code much like an integer return value from a main() procedure.

Der ExitCode Wert für einen Prozess gibt die bestimmte Konvention wieder, die vom Anwendungsentwickler für diesen Prozess implementiert wird.The ExitCode value for a process reflects the specific convention implemented by the application developer for that process. Wenn Sie den Exitcodewert verwenden, um Entscheidungen im Code zu treffen, stellen Sie sicher, dass Sie die vom Anwendungsprozess verwendete exitcodekonvention kennen.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.

Entwickler geben in der Regel einen erfolgreichen Ausgang durch einen ExitCode Wert von 0 (null) an und legen Fehler durch Werte ungleich NULL fest, die von der aufrufenden Methode verwendet werden können, um die Ursache für eine ungewöhnliche Prozess Beendigung zu identifizierenDevelopers 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. Es ist nicht erforderlich, diese Richtlinien einzuhalten, aber Sie sind die Konvention.It is not necessary to follow these guidelines, but they are the convention.

Wenn Sie versuchen, den zu erhalten ExitCode , bevor der Prozess beendet wurde, wird durch den Versuch eine Ausnahme ausgelöst.If you try to get the ExitCode before the process has exited, the attempt throws an exception. Prüfen HasExited Sie zuerst die-Eigenschaft, um zu überprüfen, ob der zugeordnete Prozess beendet wurdeExamine the HasExited property first to verify whether the associated process has terminated.

Hinweis

Wenn die Standardausgabe zu asynchronen Ereignis Handlern umgeleitet wurde, ist es möglich, dass die Ausgabe Verarbeitung nicht abgeschlossen ist, wenn HasExited zurückgibt 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. Um sicherzustellen, dass die asynchrone Ereignisverarbeitung abgeschlossen ist, müssen Sie die-Überladung aufrufen WaitForExit() , die vor der Überprüfung keinen Parameter annimmt HasExitedTo ensure that asynchronous event handling has been completed, call the WaitForExit() overload that takes no parameter before checking HasExited.

Sie können die- CloseMainWindow Methode oder die- Kill Methode verwenden, um einen zugeordneten Prozess zu beenden.You can use the CloseMainWindow or the Kill method to cause an associated process to exit.

Es gibt zwei Möglichkeiten, benachrichtigt zu werden, wenn der zugehörige Prozess beendet wird: synchron und asynchron.There are two ways of being notified when the associated process exits: synchronously and asynchronously. Die synchrone Benachrichtigung basiert auf dem Aufrufen der- WaitForExit Methode, um die Verarbeitung der Anwendung anzuhalten, bis die zugeordnete Komponente beendet wird.Synchronous notification relies on calling the WaitForExit method to pause the processing of your application until the associated component exits. Die asynchrone Benachrichtigung basiert auf dem Exited Ereignis.Asynchronous notification relies on the Exited event. Wenn die asynchrone Benachrichtigung verwendet wird, EnableRaisingEvents muss auf festgelegt werden, damit true die Process Komponente benachrichtigt wird, dass der Prozess beendet wurde.When using asynchronous notification, EnableRaisingEvents must be set to true for the Process component to receive notification that the process has exited.

Gilt für:

Siehe auch