Process.Responding Property (System.Diagnostics)

Responding Property

Switch on low bandwidth view

Collapse All

Language Filter

This page is specific to

Microsoft Visual Studio 2008/.NET Framework 3.5

Other versions are also available for the following:

.NET Framework Class Library

Process..::.Responding Property

Gets a value indicating whether the user interface of the process is responding.

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

Syntax

Visual Basic (Declaration)

Public ReadOnly Property Responding As Boolean

Visual Basic (Usage)

Dim instance As Process
Dim value As Boolean

value = instance.Responding

public bool Responding { get; }

Visual C++

public:
property bool Responding {
    bool get ();
}

JScript

public function get Responding () : boolean

Property Value

Type: System..::.Boolean
true if the user interface of the associated process is responding to the system; otherwise, false.

Exceptions

Exception	Condition
PlatformNotSupportedException	The platform is Windows 98 or Windows Millennium Edition (Windows Me); set ProcessStartInfo..::.UseShellExecute to false to access this property on Windows 98 and Windows Me.
InvalidOperationException	There is no process associated with this Process object.
NotSupportedException	You are attempting to access the Responding 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

If a process has a user interface, the Responding property contacts the user interface to determine whether the process is responding to user input. If the interface does not respond immediately, the Responding property returns false. Use this property to determine whether the interface of the associated process has stopped responding.

If the process does not have a MainWindowHandle, this property returns true.

Windows 98, Windows Millennium Edition Platform Note:

This property is not available on this platform if you started the process with ProcessStartInfo..::.UseShellExecute set to true.

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

MainWindowHandle