Obtener el uso de la CPU en C#

Aimen Fatima 12 octubre 2023

Csharp Csharp CPU

Monitoreo de Rendimiento en C#
Demostrar los Contadores de Monitoreo de Rendimiento en C#

Este tutorial explica detalladamente los parámetros de monitoreo de rendimiento que afectan sus programas. También demostraremos métodos de uso de CPU y memoria, particularmente en C#.

Monitoreo de Rendimiento en `C#`

El rendimiento de su aplicación/programa es muy importante ya que consume la memoria y el procesador de su sistema. El rendimiento del programa se puede optimizar mediante el seguimiento y la personalización de estos valores de parámetros de manera eficiente.

El procesador del sistema implica principalmente la CPU del sistema. En C#, se puede realizar un seguimiento del uso de la CPU por parte de un solo proceso y de todo el procesador.

Los contadores de memoria se pueden utilizar para realizar un seguimiento de los problemas de gestión de la memoria: el espacio de nombres System.Diagnostics proporciona la clase PerformanceCounter, que implementa todas las matrices de contadores de rendimiento.

Podemos importar este espacio de nombres y usar los métodos de la clase PerformanceCounter para diagnosticar el uso de nuestro sistema. A continuación se muestran algunos contadores de rendimiento y sus descripciones.

Usamos el formato Nombre del objeto: Contador - Descripción para incluir los siguientes contadores, donde Objeto es Monitor de rendimiento y Contador es el nombre del contador compatible con la clase PerformanceCounter.

Rendimiento del procesador

Procesador: % de tiempo del procesador: este contador indica el tiempo que el procesador dedica activamente a operar en subprocesos útiles y la frecuencia con la que estuvo ocupado respondiendo a las solicitudes.

Este contador calcula el porcentaje de tiempo que el sistema está inactivo dividido por 100%. Es fácil para el procesador calcular este parámetro ya que nunca permanece inactivo; siempre tiene algo que hacer.
Procesador: % de tiempo de usuario: el valor de este contador ayuda a identificar el tipo de procesamiento que afecta al sistema. El resultado es el valor total del tiempo productivo utilizado para las operaciones en modo Usuario. Por lo general, esto se refiere al código del programa.
Procesador: % de tiempo de interrupción: muestra la cantidad de tiempo del procesador que se utiliza para gestionar las interrupciones.
Proceso: % Tiempo de procesador - Este contador nos da el valor de tiempo que este proceso en particular usa el procesador.
Sistema: % Tiempo total del procesador: este contador le dará el rendimiento de todo el sistema al unir las actividades de todos los procesadores. Este valor será igual al %Tiempo del procesador en un sistema de un solo procesador.

Rendimiento de la memoria

Memoria: Memoria disponible: este número muestra cuánta memoria queda disponible después de que hayan finalizado las asignaciones de grupos paginados, las asignaciones de grupos no paginados, los conjuntos de trabajo de procesos y la memoria caché del sistema de archivos.
Memoria: Bytes comprometidos: este contador muestra la cantidad de memoria asignada únicamente para uso de cualquier proceso o servicio de Windows NT.
Memoria: Fallos de página/seg - Este contador especifica el número de fallos de página. La falla de página es cuando falta la información requerida en el caché o la memoria virtual.
Memoria: Páginas/seg: este contador muestra con qué frecuencia el sistema accedió al disco duro para almacenar o recuperar datos asociados a la memoria.
Proceso: Conjunto de trabajo: muestra el tamaño del área de memoria actual que utiliza el proceso para código, subprocesos y datos.

Demostrar los Contadores de Monitoreo de Rendimiento en `C#`

Crearemos un código de ejemplo de C# para demostrar los contadores de supervisión del rendimiento. Vamos a crear un proyecto vacío de C# con Visual Studio o Visual Studio Code.

El primer paso es importar el espacio de nombres Diagnóstico a su proyecto. Importarlo usando el siguiente código:

using System.Diagnostics;

Tenemos que crear objetos de la clase System.Diagnostics.PerformanceCounter. Cree dos objetos, uno para el registro del uso de la memoria y otro para el uso de la CPU, como se muestra a continuación:

protected static PerformanceCounter CPUCounter;
protected static PerformanceCounter memoryCounter;

El siguiente paso es inicializar estos objetos. Podemos inicializarlos de dos formas en C#.

Puede inicializar un objeto pasando los valores de los parámetros en el momento de su creación. En este método, no necesita llamar al constructor predeterminado.

Por ejemplo:

protected static PerformanceCounter CPUCounter =
    new PerformanceCounter(Object Name, Counter, Instance);
protected static PerformanceCounter memoryCounter = new PerformanceCounter(Category Name, Counter);

La otra forma es inicializar un objeto utilizando una palabra clave nueva y un constructor predeterminado. Los valores de los parámetros se establecen mediante el identificador de puntos para acceder a las variables.

Por ejemplo:
```
// Initialize the objects
CPUCounter = new PerformanceCounter();
memoryCounter = new PerformanceCounter();

// Assign values
CPUCounter.CategoryName = Object Name;
CPUCounter.CounterName = Counter;
CPUCounter.InstanceName = Instance;

memoryCounter.CategoryName = Object Name;
memoryCounter.CounterName = Counter;
```
Después de la inicialización, el siguiente paso es calcular los valores. El método NextValue() se utiliza para obtener el valor de los contadores.

Necesitamos llamar a estos métodos usando los respectivos objetos creados anteriormente.
```
Console.WriteLine(CPUCounter.NextValue());
```

Recuperar el uso total de CPU y memoria

El siguiente es el código completo para obtener el uso completo de la CPU y la memoria.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;

namespace ConsoleApplication1 {
  class Program {
    // create objects
    protected static PerformanceCounter CPUCounter;
    protected static PerformanceCounter memoryCounter;
    static void Main(string[] args) {
      // initialize objects
      CPUCounter = new PerformanceCounter();
      memoryCounter = new PerformanceCounter();

      // assign parameters
      CPUCounter.CategoryName = "Processor";
      CPUCounter.CounterName = "% Processor Time";
      CPUCounter.InstanceName = "_Total";

      memoryCounter.CategoryName = "Memory";
      memoryCounter.CounterName = "Available MBytes";

      // invoke the following monitoring methods
      getCpuUsage();
      getMemory();
      Console.ReadKey();
    }

    // prints the value of total processor usage time
    public static void getCpuUsage() {
      Console.WriteLine(CPUCounter.NextValue() + "%");
    }

    // prints the value of available memory
    public static void getMemory() {
      Console.WriteLine(memoryCounter.NextValue() + "MB");
    }
  }
}

El resultado del fragmento de código anterior será el uso de la CPU en % y la memoria disponible en MB de su sistema.

Recuperar el uso de CPU y memoria del proceso actual

Puede usar el siguiente fragmento de código para obtener el uso de CPU y memoria para el proceso actual.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;

namespace ConsoleApplication1 {
  class Program {
    protected static PerformanceCounter CPUCounter;
    protected static PerformanceCounter memoryCounter;
    static void Main(string[] args) {
      CPUCounter = new PerformanceCounter("Process", "% Processor Time",
                                          Process.GetCurrentProcess().ProcessName);

      memoryCounter = new PerformanceCounter("Memory", "Available MBytes");

      getCpuUsage();
      getMemory();
      Console.ReadKey();
    }

    public static void getCpuUsage() {
      Console.WriteLine(CPUCounter.NextValue() + "%");
    }

    public static void getMemory() {
      Console.WriteLine(memoryCounter.NextValue() + "MB");
    }
  }
}

El resultado del fragmento de código anterior será el procesador utilizado por el proceso actual y la memoria disponible de su sistema.

Recuperar el uso de CPU y memoria de una aplicación específica

Si desea obtener el uso de la CPU por parte de una aplicación específica, puede usar el nombre de la aplicación como una instancia en el constructor PerformanceCounter.

PerformanceCounter("Process", "% Processor Time", app_name);

Aquí está el código de ejemplo completo para obtener el uso de la CPU por parte de cualquier aplicación específica.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;

namespace ConsoleApplication1 {
  class Program {
    static void Main(string[] args) {
      CPUUsagebyApp("chrome");
    }

    private static void CPUUsagebyApp(string app_name) {
      PerformanceCounter totalCPUUsage =
          new PerformanceCounter("Processor", "% Processor Time", "_Total");
      PerformanceCounter processCPUUsage =
          new PerformanceCounter("Process", "% Processor Time", app_name);

      // loop will be executed while you don't press the enter key from the keyboard
      // you have to press space or any other key to iterate through the loop.
      do {
        float total = totalCPUUsage.NextValue();
        float process = processCPUUsage.NextValue();

        Console.WriteLine(
            String.Format("App CPU Usage = {0} {1}%", total, process, process / total * 100));

        System.Threading.Thread.Sleep(1000);

      } while (Console.ReadKey().Key != ConsoleKey.Enter);
    }
  }
}

El resultado de este fragmento de código será el uso total de la CPU de Chrome y el uso de la CPU cuando pasamos el "chrome" como parámetro. Puede leer [Supervisión del rendimiento en C#]?redirectedfrom=MSDN) para comprenderlo en profundidad.

Monitoreo de Rendimiento en C#