Process.ExitCode Eigenschap

Definitie

Naamruimte:
System.Diagnostics
Assembly:
System.dll
Assembly:
netstandard.dll

Hiermee haalt u de waarde op die is opgegeven tijdens het beëindigen van het proces.

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

Waarde van eigenschap

Int32

De code die het bijbehorende proces heeft opgegeven toen het werd beëindigd.

Kenmerken
BrowsableAttribute

Uitzonderingen

InvalidOperationException

Het proces is niet afgesloten.

– of –

Het proces Handle is ongeldig.

NotSupportedException

U probeert toegang te krijgen tot de ExitCode eigenschap voor een proces dat wordt uitgevoerd op een externe computer. Deze eigenschap is alleen beschikbaar voor processen die worden uitgevoerd op de lokale computer.

Voorbeelden

In het volgende voorbeeld wordt een exemplaar van Kladblok gestart. In het voorbeeld worden vervolgens verschillende eigenschappen van het bijbehorende proces opgehaald en weergegeven. In het voorbeeld wordt gedetecteerd wanneer het proces wordt afgesloten en wordt de afsluitcode van het proces weergegeven.

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}");
            }
        }
    }
}

open System.Diagnostics

// Define variables to track the peak
// memory usage of the process.
let mutable peakPagedMem = 0L
let mutable peakWorkingSet = 0L
let mutable peakVirtualMem = 0L

// Start the process.
use myProcess = Process.Start "NotePad.exe"

// Display the process statistics until
// the user closes the program.
while myProcess.WaitForExit 1000 |> not do
    if not myProcess.HasExited then
        // Refresh the current process property values.
        myProcess.Refresh()

        printfn ""

        // Display current process statistics.

        printfn $"{myProcess} -"
        printfn "-------------------------------------"

        printfn $"  Physical memory usage     : {myProcess.WorkingSet64}"
        printfn $"  Base priority             : {myProcess.BasePriority}"
        printfn $"  Priority class            : {myProcess.PriorityClass}"
        printfn $"  User processor time       : {myProcess.UserProcessorTime}"
        printfn $"  Privileged processor time : {myProcess.PrivilegedProcessorTime}"
        printfn $"  Total processor time      : {myProcess.TotalProcessorTime}"
        printfn $"  Paged system memory size  : {myProcess.PagedSystemMemorySize64}"
        printfn $"  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
            printfn "Status = Running"
        else
            printfn "Status = Not Responding"

printfn ""
printfn $"  Process exit code          : {myProcess.ExitCode}"

// Display peak memory statistics for the process.
printfn $"  Peak physical memory usage : {peakWorkingSet}"
printfn $"  Peak paged memory usage    : {peakPagedMem}"
printfn $"  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

Opmerkingen

Gebruik ExitCode dit om de status op te halen die het systeemproces heeft geretourneerd toen het werd afgesloten. U kunt de afsluitcode net als een retourwaarde voor een geheel getal uit een main() procedure gebruiken.

De ExitCode waarde voor een proces weerspiegelt de specifieke conventie die door de toepassingsontwikkelaar voor dat proces is geïmplementeerd. Als je de exitcodewaarde gebruikt om beslissingen te nemen in je code, zorg er dan voor dat je de exitcodeconventie kent die door het applicatieproces wordt gebruikt.

Ontwikkelaars geven meestal een geslaagde afsluiting aan met een ExitCode waarde van nul en wijzen fouten aan op basis van niet-nulwaarden die door de aanroepmethode kunnen worden gebruikt om de oorzaak van een abnormale procesafbreking te identificeren. Het is niet nodig om deze richtlijnen te volgen, maar dit zijn de conventies.

Als u het ExitCode proces probeert te verkrijgen voordat het proces is afgesloten, genereert de poging een uitzondering. Controleer eerst de HasExited eigenschap om te controleren of het bijbehorende proces is beëindigd.

Note

Wanneer standaarduitvoer is omgeleid naar asynchrone gebeurtenis-handlers, is het mogelijk dat uitvoerverwerking niet is voltooid wanneer HasExited de uitvoer wordt geretourneerd true. Om ervoor te zorgen dat de asynchrone gebeurtenisafhandeling is voltooid, roept u de WaitForExit() overbelasting aan die geen parameter nodig heeft voordat u deze controleert HasExited.

U kunt de CloseMainWindow of de Kill methode gebruiken om ervoor te zorgen dat een gekoppeld proces wordt afgesloten.

Er zijn twee manieren om op de hoogte te worden gesteld wanneer het bijbehorende proces wordt afgesloten: synchroon en asynchroon. Synchrone melding is afhankelijk van het aanroepen van de WaitForExit methode om de verwerking van uw toepassing te onderbreken totdat het bijbehorende onderdeel wordt afgesloten. Asynchrone melding is afhankelijk van de Exited gebeurtenis. Wanneer u een asynchrone melding gebruikt, EnableRaisingEvents moet deze worden ingesteld op true het Process onderdeel om een melding te ontvangen dat het proces is afgesloten.

Van toepassing op

Zie ook