Process.ExitCode Propiedad

Definición

Obtiene el valor especificado por el proceso asociado al terminar.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

Valor de propiedad

Int32

Código especificado por el proceso asociado al terminar.The code that the associated process specified when it terminated.

Atributos

Excepciones

El proceso no finalizó.The process has not exited.

o bien-or- El proceso Handle no es válido.The process Handle is not valid.

Está intentando obtener acceso a la propiedad ExitCode de un proceso que se ejecuta en un equipo remoto.You are trying to access the ExitCode property for a process that is running on a remote computer. Esta propiedad está disponible únicamente para los procesos que se ejecutan en el equipo local.This property is available only for processes that are running on the local computer.

Ejemplos

En el ejemplo siguiente se inicia una instancia del Bloc de notas.The following example starts an instance of Notepad. A continuación, en el ejemplo se recuperan y se muestran las distintas propiedades del proceso asociado.The example then retrieves and displays various properties of the associated process. En el ejemplo se detecta cuándo finaliza el proceso y se muestra el código de salida del proceso.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

Comentarios

Utilice ExitCode para obtener el estado devuelto por el proceso del sistema cuando salió.Use ExitCode to get the status that the system process returned when it exited. Puede usar el código de salida de forma similar a un valor entero devuelto de un main() procedimiento.You can use the exit code much like an integer return value from a main() procedure.

El ExitCode valor de un proceso refleja la Convención específica implementada por el desarrollador de la aplicación para ese proceso.The ExitCode value for a process reflects the specific convention implemented by the application developer for that process. Si usa el valor del código de salida para tomar decisiones en el código, asegúrese de que conoce la Convención de código de salida utilizada por el proceso de la aplicación.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.

Los desarrolladores suelen indicar una salida correcta con un ExitCode valor de cero y designar errores con valores distintos de cero que el método de llamada puede usar para identificar la causa de una terminación anómala del proceso.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. No es necesario seguir estas instrucciones, pero son la Convención.It is not necessary to follow these guidelines, but they are the convention.

Si intenta obtener el ExitCode antes de salir del proceso, el intento produce una excepción.If you try to get the ExitCode before the process has exited, the attempt throws an exception. Examine HasExited primero la propiedad para comprobar si el proceso asociado ha finalizado.Examine the HasExited property first to verify whether the associated process has terminated.

Nota

Cuando se ha redirigido la salida estándar a los controladores de eventos asincrónicos, es posible que el procesamiento de salida no se haya completado cuando se HasExited devuelva 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. Para asegurarse de que se ha completado el control de eventos asincrónicos, llame a la WaitForExit() sobrecarga que no toma ningún parámetro antes de realizar la comprobación HasExited .To ensure that asynchronous event handling has been completed, call the WaitForExit() overload that takes no parameter before checking HasExited.

Puede usar el CloseMainWindow Kill método o para hacer que un proceso asociado salga.You can use the CloseMainWindow or the Kill method to cause an associated process to exit.

Hay dos maneras de recibir notificaciones cuando finaliza el proceso asociado: sincrónicamente y de forma asincrónica.There are two ways of being notified when the associated process exits: synchronously and asynchronously. La notificación sincrónica se basa en llamar al WaitForExit método para pausar el procesamiento de la aplicación hasta que se cierre el componente asociado.Synchronous notification relies on calling the WaitForExit method to pause the processing of your application until the associated component exits. La notificación asincrónica se basa en el Exited evento.Asynchronous notification relies on the Exited event. Al utilizar la notificación asincrónica, EnableRaisingEvents debe establecerse en true para que el Process componente reciba la notificación de que el proceso ha salido.When using asynchronous notification, EnableRaisingEvents must be set to true for the Process component to receive notification that the process has exited.

Se aplica a

Consulte también