Process.PriorityClass Process.PriorityClass Process.PriorityClass Process.PriorityClass Property

Definizione

Ottiene o imposta la categoria di priorità globale per il processo associato.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

Valore della proprietà

Categoria di priorità del processo associato, dalla quale viene calcolata la proprietà BasePriority del processo.The priority category for the associated process, from which the BasePriority of the process is calculated.

Eccezioni

Non è stato possibile impostare o recuperare le informazioni sulla priorità del processo dalla risorsa di processo associata.Process priority information could not be set or retrieved from the associated process resource.

In alternativa-or- L'identificatore di processo o l'handle di processo è zeroThe process identifier or process handle is zero. (il processo non è stato avviato).(The process has not been started.)

Si sta provando ad accedere alla proprietà PriorityClass per un processo in esecuzione in un computer remoto.You are attempting to access the PriorityClass 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.

La proprietà PriorityClass è stata impostata su AboveNormal o BelowNormal quando si usa Windows 98 o Windows Millennium Edition (Windows Me).You have set the PriorityClass to AboveNormal or BelowNormal when using Windows 98 or Windows Millennium Edition (Windows Me). Queste piattaforme non supportano tali valori per la classe di priorità.These platforms do not support those values for the priority class.

La classe di priorità non può essere impostata perché non usa un valore valido, come definito nell'enumerazione ProcessPriorityClass.Priority class cannot be set because it does not use a valid value, as defined in the ProcessPriorityClass enumeration.

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

Una classe di priorità del processo include una gamma di livelli di priorità di thread.A process priority class encompasses a range of thread priority levels. Thread con priorità diverse che sono in esecuzione nel processo di esecuzione rispetto alla classe di priorità del processo.Threads with different priorities that are running in the process run relative to the priority class of the process. Win32 Usa quattro classi di priorità con sette livelli di priorità di base per ogni classe.Win32 uses four priority classes with seven base priority levels per class. Queste classi di priorità del processo vengono acquisite nel ProcessPriorityClass enumerazione, che consente di imposta la priorità del processo Idle, Normal, High, AboveNormal, BelowNormal, o RealTime.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. In base al tempo trascorso o altri degli incrementi, il livello di priorità di base possono essere modificati dal sistema operativo quando è necessario attivare prima degli altri per l'accesso al processore di un processo.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. Inoltre, è possibile impostare il PriorityBoostEnabled per aumentare temporaneamente il livello di priorità di thread che sono state intraprese dallo stato di attesa.In addition, you can set the PriorityBoostEnabled to temporarily boost the priority level of threads that have been taken out of the wait state. La priorità viene reimpostata quando il processo restituisce lo stato di attesa.The priority is reset when the process returns to the wait state.

Il BasePriority proprietà consente di visualizzare la priorità iniziale che viene assegnata a un processo.The BasePriority property lets you view the starting priority that is assigned to a process. Tuttavia, poiché si tratta di sola lettura, è possibile usare il BasePriority proprietà per impostare la priorità di un processo.However, because it is read-only, you cannot use the BasePriority property to set the priority of a process. Per modificare la priorità, usare il PriorityClass proprietà, che ottiene o imposta la categoria di priorità globale per il processo.To change the priority, use the PriorityClass property, which gets or sets the overall priority category for the process.

La classe di priorità non è possibile visualizzare tramite Monitor di sistema.The priority class cannot be viewed using System Monitor. La tabella seguente illustra la relazione tra il BasePriority e PriorityClass valori.The following table shows the relationship between the BasePriority and PriorityClass values.

BasePriorityBasePriority Classe di prioritàPriorityClass
44 Idle
88 Normal
1313 High
2424 RealTime

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