Rufen Sie die CPU-Auslastung in C# ab

Aimen Fatima 12 Oktober 2023

Csharp Csharp CPU

Leistungsüberwachung in C#
Demonstrieren Sie die Leistungsüberwachungszähler in C#

Dieses Lernprogramm erklärt ausführlich die Leistungsüberwachungsparameter, die sich auf Ihre Programme auswirken. Wir werden auch CPU- und Speichernutzungsmethoden demonstrieren, insbesondere in C#.

Leistungsüberwachung in `C#`

Die Leistung Ihrer Anwendung/Ihres Programms ist sehr wichtig, da sie den Speicher und den Prozessor Ihres Systems verbraucht. Die Leistung des Programms kann optimiert werden, indem diese Parameterwerte effizient verfolgt und angepasst werden.

Der Prozessor des Systems deutet meistens die CPU des Systems an. In C# kann die CPU-Auslastung durch einen einzelnen Prozess und den gesamten Prozessor verfolgt werden.

Speicherzähler können verwendet werden, um Speicherverwaltungsprobleme zu verfolgen – der Namensraum System.Diagnostics stellt die Klasse PerformanceCounter bereit, die alle Leistungszählermatrizen implementiert.

Wir können diesen Namespace importieren und die Klassenmethoden PerformanceCounter verwenden, um unsere Systemnutzung zu diagnostizieren. Im Folgenden finden Sie einige Leistungsindikatoren und ihre Beschreibungen.

Wir verwenden das Format Objektname: Zähler – Beschreibung, um die folgenden Zähler einzutragen, wobei Objekt der Leistungsmonitor ist und der Zähler der Name des Zählers ist, der von der Klasse PerformanceCounter unterstützt wird.

Prozessorleistung

Processor: Processor Time in % – Dieser Zähler zeigt die Zeit an, die der Prozessor aktiv der Arbeit an nützlichen Threads widmet, und wie oft er mit der Beantwortung von Anfragen beschäftigt war.

Dieser Zähler berechnet den Prozentsatz der Zeit, in der das System inaktiv ist, dividiert durch 100%. Für den Prozessor ist es einfach, diesen Parameter zu berechnen, da er niemals im Leerlauf ist; es hat immer was zu tun.
Prozessor: % Benutzerzeit – Der Wert dieses Zählers hilft bei der Identifizierung der Art der Verarbeitung, die sich auf das System auswirkt. Das Ergebnis ist der gesamte Wert der produktiven Zeit, die für Operationen im Benutzer-Modus verwendet wird. Typischerweise bezieht sich dies auf Programmcode.
Processor: % Interrupt Time – Zeigt an, wie viel Prozessorzeit für die Verarbeitung von Interrupts verwendet wird.
Prozess: Prozessorzeit in % – Dieser Zähler gibt uns den Wert der Zeit an, die dieser bestimmte Prozess den Prozessor verwendet.
System: % Gesamtprozessorzeit – Dieser Zähler gibt Ihnen die Leistung des gesamten Systems an, indem er die Aktivitäten aller Prozessoren zusammenfasst. Dieser Wert entspricht der %Prozessorzeit in einem Einzelprozessorsystem.

Speicherleistung

Memory: Available Memory – Diese Zahl zeigt an, wie viel Speicher noch verfügbar ist, nachdem ausgelagerte Poolzuweisungen, nicht ausgelagerte Poolzuweisungen, Prozessarbeitssätze und Dateisystemcache abgeschlossen sind.
Memory: Committed Bytes – Dieser Zähler zeigt die zugewiesene Speichermenge ausschließlich für die Verwendung durch Windows NT-Prozesse oder -Dienste.
Speicher: Seitenfehler/Sek - Dieser Zähler gibt die Anzahl der Seitenfehler an. Ein Seitenfehler liegt vor, wenn die erforderlichen Informationen im Cache oder im virtuellen Speicher fehlen.
Speicher: Seiten/Sek – Dieser Zähler zeigt an, wie oft das System auf die Festplatte zugegriffen hat, um speicherbezogene Daten zu speichern oder abzurufen.
Process: Working Set – Zeigt die aktuelle Größe des Speicherbereichs an, den der Prozess für Code, Threads und Daten verwendet.

Demonstrieren Sie die Leistungsüberwachungszähler in `C#`

Wir werden einen C#-Beispielcode erstellen, um die Leistungsüberwachungszähler zu demonstrieren. Lassen Sie uns ein leeres C#-Projekt entweder mit Visual Studio oder Visual Studio Code erstellen.

Im ersten Schritt importieren Sie den Namensraum Diagnostics in Ihr Projekt. Importieren Sie es mit dem folgenden Code:

using System.Diagnostics;

Wir müssen Objekte der Klasse System.Diagnostics.PerformanceCounter erstellen. Erstellen Sie zwei Objekte, eines für die Aufzeichnung der Speicherauslastung und das andere für die CPU-Auslastung, wie folgt:

protected static PerformanceCounter CPUCounter;
protected static PerformanceCounter memoryCounter;

Der nächste Schritt besteht darin, diese Objekte zu initialisieren. Wir können sie in C# auf zwei Arten initialisieren.

Sie können ein Objekt initialisieren, indem Sie die Parameterwerte zum Zeitpunkt seiner Erstellung übergeben. In dieser Methode müssen Sie den Standardkonstruktor nicht aufrufen.

Zum Beispiel:

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

Die andere Möglichkeit besteht darin, ein Objekt mit dem Schlüsselwort new und dem Standardkonstruktor zu initialisieren. Die Parameterwerte werden mit der Punktkennung gesetzt, um auf die Variablen zuzugreifen.

Zum Beispiel:
```
// 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;
```
Nach der Initialisierung besteht der nächste Schritt darin, Werte zu berechnen. Die Methode NextValue() wird verwendet, um den Wert von Zählern zu erhalten.

Wir müssen diese Methoden mit den entsprechenden oben erstellten Objekten aufrufen.
```
Console.WriteLine(CPUCounter.NextValue());
```

Rufen Sie die gesamte CPU- und Speicherauslastung ab

Es folgt der vollständige Code, um die gesamte CPU- und Speicherauslastung abzurufen.

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");
    }
  }
}

Die Ausgabe des obigen Code-Snippets ist die CPU-Auslastung in % und der verfügbare Arbeitsspeicher in MB Ihres Systems.

Rufen Sie die CPU- und Speicherauslastung des aktuellen Prozesses ab

Sie können das folgende Code-Snippet verwenden, um die CPU- und Speicherauslastung für den aktuellen Prozess abzurufen.

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");
    }
  }
}

Die Ausgabe des obigen Code-Snippets ist der vom aktuellen Prozess verwendete Prozessor und der verfügbare Arbeitsspeicher Ihres Systems.

Abrufen der CPU- und Speicherauslastung einer bestimmten Anwendung

Wenn Sie die CPU-Auslastung einer bestimmten Anwendung abrufen möchten, können Sie den Anwendungsnamen als Instanz im Konstruktor PerformanceCounter verwenden.

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

Hier ist der vollständige Beispielcode zum Abrufen der CPU-Auslastung durch eine bestimmte App.

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);
    }
  }
}

Die Ausgabe dieses Code-Snippets ist die gesamte CPU-Auslastung von Chrome und die CPU-Auslastung, da wir "chrome" als Parameter übergeben haben. Sie können [Leistungsüberwachung in C#]?redirectedfrom=MSDN) lesen, um ein tieferes Verständnis zu erlangen.

Leistungsüberwachung in C#