Process.PriorityClass Eigenschaft

Definition

Ruft die allgemeine Prioritätskategorie für den zugeordneten Prozess ab oder legt diese fest.Gets or sets the overall priority category for the associated process.

public:
 property System::Diagnostics::ProcessPriorityClass PriorityClass { System::Diagnostics::ProcessPriorityClass get(); void set(System::Diagnostics::ProcessPriorityClass value); };
public System.Diagnostics.ProcessPriorityClass PriorityClass { get; set; }
member this.PriorityClass : System.Diagnostics.ProcessPriorityClass with get, set
Public Property PriorityClass As ProcessPriorityClass

Eigenschaftswert

ProcessPriorityClass

Die Prioritätskategorie für den zugeordneten Prozess, aus der die BasePriority des Prozesses berechnet wird.The priority category for the associated process, from which the BasePriority of the process is calculated.

Ausnahmen

Es konnten keine Prozessprioritätsinformationen festgelegt oder von der zugeordneten Prozessressource abgerufen werden.Process priority information could not be set or retrieved from the associated process resource.

- oder --or-

Die Prozess-ID oder das Prozesshandle ist 0 (null).The process identifier or process handle is zero. (Der Prozess wurde nicht gestartet.)(The process has not been started.)

Sie versuchen, auf die PriorityClass-Eigenschaft für einen Prozess zuzugreifen, der auf einem Remotecomputer ausgeführt wird.You are attempting to access the PriorityClass property for a process that is running on a remote computer. Diese Eigenschaft ist nur für Prozesse verfügbar, die auf dem lokalen Computer ausgeführt werden.This property is available only for processes that are running on the local computer.

Der Prozess Id ist nicht verfügbar.The process Id is not available.

Die Prioritätsklasse kann nicht festgelegt werden, weil sie keinen gültigen Wert gemäß der Definition in der ProcessPriorityClass-Enumeration verwendet.Priority class cannot be set because it does not use a valid value, as defined in the ProcessPriorityClass enumeration.

Beispiele

Im folgenden Beispiel wird eine Instanz von Editor gestartet.The following example starts an instance of Notepad. Im Beispiel werden dann die verschiedenen Eigenschaften des zugeordneten Prozesses abgerufen und angezeigt.The example then retrieves and displays various properties of the associated process. Das Beispiel erkennt, wenn der Prozess beendet wird, und zeigt den Exitcode des Prozesses an.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

Hinweise

Der von dieser Eigenschaft zurückgegebene Wert stellt die zuletzt aktualisierte Priorität des Prozesses dar.The value returned by this property represents the most recently refreshed priority of the process. Um die aktuellste Priorität zu erhalten, müssen Sie zuerst die- Refresh() Methode aufzurufen.To get the most up to date priority, you need to call Refresh() method first.

Eine Prozess Prioritäts Klasse umfasst eine Reihe von Thread Prioritäts Ebenen.A process priority class encompasses a range of thread priority levels. Threads mit unterschiedlichen Prioritäten, die im Prozess ausgeführt werden, werden relativ zur Prioritäts Klasse des Prozesses ausgeführt.Threads with different priorities that are running in the process run relative to the priority class of the process. Win32 verwendet vier Prioritäts Klassen mit sieben Basis Prioritätsstufen pro Klasse.Win32 uses four priority classes with seven base priority levels per class. Diese Prozess Prioritäts Klassen werden in der- ProcessPriorityClass Enumeration aufgezeichnet, mit der Sie die Prozesspriorität auf Idle , Normal , High , AboveNormal , oder BelowNormal RealTime festlegen können.These process priority classes are captured in the ProcessPriorityClass enumeration, which lets you set the process priority to Idle, Normal, High, AboveNormal, BelowNormal, or RealTime. Basierend auf der verstrichenen Zeit oder anderen Steigerungen kann die Basis Prioritätsstufe vom Betriebssystem geändert werden, wenn ein Prozess für den Zugriff auf den Prozessor vor anderen versetzt werden muss.Based on the time elapsed or other boosts, the base priority level can be changed by the operating system when a process needs to be put ahead of others for access to the processor. Außerdem können Sie festlegen, PriorityBoostEnabled um die Prioritäts Ebene der Threads, die aus dem Wartezustand herausgenommen wurden, vorübergehend zu erhöhen.In addition, you can set the PriorityBoostEnabled to temporarily boost the priority level of threads that have been taken out of the wait state. Die Priorität wird zurückgesetzt, wenn der Prozess in den Wartezustand zurückkehrt.The priority is reset when the process returns to the wait state.

Mit der- BasePriority Eigenschaft können Sie die Anfangs Priorität anzeigen, die einem Prozess zugewiesen ist.The BasePriority property lets you view the starting priority that is assigned to a process. Da Sie jedoch schreibgeschützt ist, können Sie die-Eigenschaft nicht verwenden, BasePriority um die Priorität eines Prozesses festzulegen.However, because it is read-only, you cannot use the BasePriority property to set the priority of a process. Um die Priorität zu ändern, verwenden Sie die- PriorityClass Eigenschaft, mit der die Kategorie Gesamt Priorität für den Prozess abgerufen oder festgelegt wird.To change the priority, use the PriorityClass property, which gets or sets the overall priority category for the process.

Die Prioritäts Klasse kann nicht mit dem System Monitor angezeigt werden.The priority class cannot be viewed using System Monitor. In der folgenden Tabelle wird die Beziehung zwischen BasePriority den PriorityClass Werten und angezeigt.The following table shows the relationship between the BasePriority and PriorityClass values.

BasePriorityBasePriority PriorityClassPriorityClass
44 Idle
88 Normal
1313 High
2424 RealTime

Gilt für:

Siehe auch