Process.ExitCode Process.ExitCode Process.ExitCode Process.ExitCode Property

Definizione

Ottiene il valore specificato dal processo associato quando è stato terminato.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

Valore della proprietà

Codice specificato dal processo associato quando è stato terminato.The code that the associated process specified when it terminated.

Eccezioni

Il processo non è terminato.The process has not exited.

In alternativa-or- Il processo Handle non è valido.The process Handle is not valid.

Si sta provando ad accedere alla proprietà ExitCode per un processo in esecuzione in un computer remoto.You are trying to access the ExitCode property for a process that is running on a remote computer. Questa proprietà è disponibile solo per i processi in esecuzione nel computer locale.This property is available only for processes that are running on the local computer.

Esempi

Nell'esempio seguente viene avviata un'istanza del blocco note.The following example starts an instance of Notepad. L'esempio recupera quindi e consente di visualizzare varie proprietà del processo associato.The example then retrieves and displays various properties of the associated process. Nell'esempio viene rilevato durante il processo viene chiuso e consente di visualizzare il codice di uscita del processo.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
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 'Main
    End Class
End Namespace

Commenti

Usare ExitCode per ottenere lo stato restituito il processo di sistema quando è stato terminato.Use ExitCode to get the status that the system process returned when it exited. È possibile usare il codice di uscita molto, analogamente a un numero intero restituito da una main() procedure.You can use the exit code much like an integer return value from a main() procedure.

Il ExitCode valore per un processo riflette la convenzione specifica implementata dallo sviluppatore dell'applicazione per tale processo.The ExitCode value for a process reflects the specific convention implemented by the application developer for that process. Se si usa il valore di codice di uscita per prendere decisioni nel codice, assicurarsi di conoscere la convenzione di codice di uscita usata dal processo di applicazione.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.

Gli sviluppatori in genere indicano l'esito positivo da una ExitCode pari a zero e definiscono come errori da valori diversi da zero che il metodo chiamante può usare per identificare la causa di una chiusura processo anomalo.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. Non è necessario seguire queste linee guida, ma sono la convenzione.It is not necessary to follow these guidelines, but they are the convention.

Se si prova a ottenere il ExitCode prima che il processo è terminato, il tentativo di genera un'eccezione.If you try to get the ExitCode before the process has exited, the attempt throws an exception. Esaminare il HasExited proprietà prima di tutto per verificare se è stato terminato il processo associato.Examine the HasExited property first to verify whether the associated process has terminated.

Nota

Quando l'output standard è stato reindirizzato per gestori eventi asincroni, è possibile che l'elaborazione di output non deve avere completato quando HasExited restituisce 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. Per assicurarsi che gestione asincrona degli eventi è stata completata, chiamare il WaitForExit() overload che non accetta alcun parametro prima di archiviare HasExited.To ensure that asynchronous event handling has been completed, call the WaitForExit() overload that takes no parameter before checking HasExited.

È possibile usare la CloseMainWindow o il Kill metodo a causa di un processo venga terminato.You can use the CloseMainWindow or the Kill method to cause an associated process to exit.

Esistono due modi per visualizzare una notifica quando il processo associato viene chiuso: in modo sincrono e asincrono.There are two ways of being notified when the associated process exits: synchronously and asynchronously. La notifica sincrona si basa sulla chiamata di WaitForExit metodo sospendere l'elaborazione dell'applicazione fino a quando non viene chiuso il componente associato.Synchronous notification relies on calling the WaitForExit method to pause the processing of your application until the associated component exits. Notifica asincrona si basa sul Exited evento.Asynchronous notification relies on the Exited event. Quando si utilizza la notifica asincrona EnableRaisingEvents deve essere impostata su true per il Process componente per ricevere una notifica che il processo è terminato.When using asynchronous notification, EnableRaisingEvents must be set to true for the Process component to receive notification that the process has exited.

Sicurezza

LinkDemand
per un'attendibilità totale per il chiamante immediato.for full trust for the immediate caller. Impossibile utilizzare questo membro in codice parzialmente attendibile.This member cannot be used by partially trusted code.

Si applica a

Vedi anche