Process.PriorityClass Propiedad

Definición

Obtiene o establece la categoría de prioridad general del proceso asociado.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

Valor de propiedad

ProcessPriorityClass

Categoría de prioridad del proceso asociado a partir de la cual se calcula el BasePriority del proceso.The priority category for the associated process, from which the BasePriority of the process is calculated.

Excepciones

La información de la prioridad del proceso no pudo establecerse o recuperarse del recurso del proceso asociado.Process priority information could not be set or retrieved from the associated process resource.

o bien-or-

El identificador del proceso o el controlador del proceso es cero.The process identifier or process handle is zero. (No se ha iniciado el proceso).(The process has not been started.)

Está intentando obtener acceso a la propiedad PriorityClass de un proceso que se ejecuta en un equipo remoto.You are attempting to access the PriorityClass property for a process that is running on a remote computer. Esta propiedad está disponible únicamente para los procesos que se ejecutan en el equipo local.This property is available only for processes that are running on the local computer.

El proceso Id no está disponible.The process Id is not available.

No se puede establecer la clase de prioridad porque no usa un valor válido, según se define en la enumeración ProcessPriorityClass.Priority class cannot be set because it does not use a valid value, as defined in the ProcessPriorityClass enumeration.

Ejemplos

En el ejemplo siguiente se inicia una instancia del Bloc de notas.The following example starts an instance of Notepad. A continuación, en el ejemplo se recuperan y se muestran las distintas propiedades del proceso asociado.The example then retrieves and displays various properties of the associated process. En el ejemplo se detecta cuándo finaliza el proceso y se muestra el código de salida del proceso.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

Comentarios

El valor devuelto por esta propiedad representa la prioridad actualizada más recientemente del proceso.The value returned by this property represents the most recently refreshed priority of the process. Para obtener la prioridad más actualizada, debe llamar Refresh() primero al método.To get the most up to date priority, you need to call Refresh() method first.

Una clase de prioridad de proceso abarca un intervalo de niveles de prioridad de subproceso.A process priority class encompasses a range of thread priority levels. Los subprocesos con diferentes prioridades que se ejecutan en el proceso se ejecutan en relación con la clase de prioridad del proceso.Threads with different priorities that are running in the process run relative to the priority class of the process. Win32 utiliza cuatro clases de prioridad con siete niveles de prioridad base por clase.Win32 uses four priority classes with seven base priority levels per class. Estas clases de prioridad de proceso se capturan en la ProcessPriorityClass enumeración, lo que permite establecer la prioridad del proceso en 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. Según el tiempo transcurrido u otros aumentos, el nivel de prioridad base se puede cambiar por el sistema operativo cuando es necesario colocar un proceso por encima de otros para obtener acceso al procesador.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. Además, puede establecer PriorityBoostEnabled para que aumente de forma temporal el nivel de prioridad de los subprocesos que se han sacado del estado de espera.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 prioridad se restablece cuando el proceso vuelve al estado de espera.The priority is reset when the process returns to the wait state.

La BasePriority propiedad permite ver la prioridad de inicio que se asigna a un proceso.The BasePriority property lets you view the starting priority that is assigned to a process. Sin embargo, dado que es de solo lectura, no puede usar la BasePriority propiedad para establecer la prioridad de un proceso.However, because it is read-only, you cannot use the BasePriority property to set the priority of a process. Para cambiar la prioridad, use la PriorityClass propiedad, que obtiene o establece la categoría de prioridad general del proceso.To change the priority, use the PriorityClass property, which gets or sets the overall priority category for the process.

La clase Priority no se puede ver mediante el monitor de sistema.The priority class cannot be viewed using System Monitor. En la tabla siguiente se muestra la relación entre los BasePriority PriorityClass valores y.The following table shows the relationship between the BasePriority and PriorityClass values.

BasePriorityBasePriority PriorityClassPriorityClass
44 Idle
88 Normal
1313 High
2424 RealTime

Se aplica a

Consulte también