Process.ExitCode Property (System.Diagnostics)

Microsoft Developer Network

ExitCode Property

.NET Framework Class Library

Process..::.ExitCode Property

Gets the value that the associated process specified when it terminated.

Namespace: System.Diagnostics
Assembly: System (in System.dll)

Syntax

Visual Basic (Declaration)

<BrowsableAttribute(False)> _
Public ReadOnly Property ExitCode As Integer

Visual Basic (Usage)

Dim instance As Process
Dim value As Integer

value = instance.ExitCode

[BrowsableAttribute(false)]
public int ExitCode { get; }

Visual C++

[BrowsableAttribute(false)]
public:
property int ExitCode {
    int get ();
}

JScript

public function get ExitCode () : int

Property Value

Type: System..::.Int32
The code that the associated process specified when it terminated.

Exceptions

Exception	Condition
InvalidOperationException	The process has not exited. -or- The process Handle is not valid.
NotSupportedException	You are trying to access the ExitCode property for a process that is running on a remote computer. This property is available only for processes that are running on the local computer.

Exception

Condition

InvalidOperationException

The process has not exited.

-or-

The process Handle is not valid.

NotSupportedException

You are trying to access the ExitCode property for a process that is running on a remote computer. This property is available only for processes that are running on the local computer.

Remarks

Use ExitCode to get the status that the system process returned when it exited. You can use the exit code much like an integer return value from a main() procedure.

The ExitCode value for a process reflects the specific convention implemented by the application developer for that process. 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.

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. It is not necessary to follow these guidelines, but they are the convention.

If you try to get the ExitCode before the process has exited, the attempt throws an exception. Examine the HasExited property first to verify whether the associated process has terminated.

You can use the CloseMainWindow or the Kill method to cause an associated process to exit.

There are two ways of being notified when the associated process exits: synchronously and asynchronously. Synchronous notification relies on calling the WaitForExit method to pause the processing of your application until the associated component exits. Asynchronous notification relies on the Exited event. In either case, EnableRaisingEvents must be set to true for the Process component to receive notification that the process has exited.

Examples

The following example starts an instance of Notepad. The example then retrieves and displays various properties of the associated process. The example detects when the process exits, and displays the process's exit code.

Visual Basic

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

         Dim myProcess As Process = Nothing

         Try

            ' Start the process.
            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("{0} -", myProcess.ToString())
                    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)

                    ' 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: {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 Not myProcess Is Nothing Then
                myProcess.Close
            End If
         End Try
      End Sub 'Main
   End Class 
End Namespace

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;

            Process myProcess = null;

            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.ToString());
                        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);

                        // 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 != null)
                {
                    myProcess.Close();
                }
            }
        }

    }
}

Visual C++

#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 );

            // 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();
      }
   }

}

.NET Framework Security

LinkDemand
for full trust for the immediate caller. This member cannot be used by partially trusted code.

Platforms

Windows 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

Version Information

.NET Framework

Supported in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 3.5, 2.0

Reference

Process Class

Process Members

System.Diagnostics Namespace