Wie erhalte ich die CPU-Auslastung in C #?

Ich möchte die Gesamt-CPU-Auslastung für eine Anwendung in C # ermitteln. Ich habe viele Möglichkeiten gefunden, um die Eigenschaften von Prozessen zu untersuchen, aber ich möchte nur die CPU-Auslastung der Prozesse und die Gesamt-CPU, wie Sie sie im TaskManager erhalten.

Wie mache ich das?

Sie können die PerformanceCounter- Klasse von System.Diagnostics verwenden .

Initialisieren Sie wie folgt:

PerformanceCounter cpuCounter;
PerformanceCounter ramCounter;

cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
ramCounter = new PerformanceCounter("Memory", "Available MBytes");

Konsumiere so:

public string getCurrentCpuUsage(){
            return cpuCounter.NextValue()+"%";
}

public string getAvailableRAM(){
            return ramCounter.NextValue()+"MB";
} 

Etwas mehr als erforderlich, aber ich verwende den zusätzlichen Timer-Code, um zu verfolgen und zu warnen, ob die CPU-Auslastung über einen längeren Zeitraum von 1 Minute oder länger 90% oder mehr beträgt.

public class Form1
{

    int totalHits = 0;

    public object getCPUCounter()
    {

        PerformanceCounter cpuCounter = new PerformanceCounter();
        cpuCounter.CategoryName = "Processor";
        cpuCounter.CounterName = "% Processor Time";
        cpuCounter.InstanceName = "_Total";

                     // will always start at 0
        dynamic firstValue = cpuCounter.NextValue();
        System.Threading.Thread.Sleep(1000);
                    // now matches task manager reading
        dynamic secondValue = cpuCounter.NextValue();

        return secondValue;

    }


    private void Timer1_Tick(Object sender, EventArgs e)
    {
        int cpuPercent = (int)getCPUCounter();
        if (cpuPercent >= 90)
        {
            totalHits = totalHits + 1;
            if (totalHits == 60)
            {
                Interaction.MsgBox("ALERT 90% usage for 1 minute");
                totalHits = 0;
            }                        
        }
        else
        {
            totalHits = 0;
        }
        Label1.Text = cpuPercent + " % CPU";
        //Label2.Text = getRAMCounter() + " RAM Free";
        Label3.Text = totalHits + " seconds over 20% usage";
    }
}

Nachdem ich einige Zeit damit verbracht hatte, ein paar verschiedene Themen zu lesen, die ziemlich kompliziert erschienen, kam ich auf diese Idee. Ich brauchte es für einen 8-Kern-Computer, auf dem ich den SQL Server überwachen wollte. Für den folgenden Code habe ich dann "sqlservr" als appName übergeben.

private static void RunTest(string appName)
{
    bool done = false;
    PerformanceCounter total_cpu = new PerformanceCounter("Process", "% Processor Time", "_Total");
    PerformanceCounter process_cpu = new PerformanceCounter("Process", "% Processor Time", appName);
    while (!done)
    {
        float t = total_cpu.NextValue();
        float p = process_cpu.NextValue();
        Console.WriteLine(String.Format("_Total = {0}  App = {1} {2}%\n", t, p, p / t * 100));
        System.Threading.Thread.Sleep(1000);
    }
}

Es scheint den Prozentsatz der von SQL auf meinem 8-Core-Server verwendeten CPU korrekt zu messen.

Es ist in Ordnung, ich habe es verstanden! Danke für Ihre Hilfe!

Hier ist der Code dafür:

private void button1_Click(object sender, EventArgs e)
{
    selectedServer = "JS000943";
    listBox1.Items.Add(GetProcessorIdleTime(selectedServer).ToString());
}

private static int GetProcessorIdleTime(string selectedServer)
{
    try
    {
        var searcher = new
           ManagementObjectSearcher
             (@"\\"+ selectedServer +@"\root\CIMV2",
              "SELECT * FROM Win32_PerfFormattedData_PerfOS_Processor WHERE Name=\"_Total\"");

        ManagementObjectCollection collection = searcher.Get();
        ManagementObject queryObj = collection.Cast<ManagementObject>().First();

        return Convert.ToInt32(queryObj["PercentIdleTime"]);
    }
    catch (ManagementException e)
    {
        MessageBox.Show("An error occurred while querying for WMI data: " + e.Message);
    }
    return -1;
}

Sie können WMI verwenden, um Informationen zum CPU-Prozentsatz abzurufen. Sie können sich sogar bei einem Remotecomputer anmelden, wenn Sie über die richtigen Berechtigungen verfügen. Unter http://www.csharphelp.com/archives2/archive334.html erhalten Sie eine Vorstellung davon, was Sie erreichen können.

Hilfreich könnte auch die MSDN-Referenz für den Win32_Process- Namespace sein.

Siehe auch ein CodeProject-Beispiel. Gewusst wie: (Fast) alles in WMI über C # .

CMS hat es richtig gemacht, aber auch wenn Sie den Server-Explorer in Visual Studio verwenden und mit der Registerkarte Leistungsindikator herumspielen, können Sie herausfinden, wie Sie viele nützliche Metriken erhalten.

Dies scheint für mich zu funktionieren, ein Beispiel für das Warten, bis der Prozessor einen bestimmten Prozentsatz erreicht

var cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
int usage = (int) cpuCounter.NextValue();
while (usage == 0 || usage > 80)
{
     Thread.Sleep(250);
     usage = (int)cpuCounter.NextValue();
}

Diese Klasse fragt den Zähler automatisch alle 1 Sekunden ab und ist außerdem threadsicher:

public class ProcessorUsage
{
    const float sampleFrequencyMillis = 1000;

    protected object syncLock = new object();
    protected PerformanceCounter counter;
    protected float lastSample;
    protected DateTime lastSampleTime;

    /// <summary>
    /// 
    /// </summary>
    public ProcessorUsage()
    {
        this.counter = new PerformanceCounter("Processor", "% Processor Time", "_Total", true);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <returns></returns>
    public float GetCurrentValue()
    {
        if ((DateTime.UtcNow - lastSampleTime).TotalMilliseconds > sampleFrequencyMillis)
        {
            lock (syncLock)
            {
                if ((DateTime.UtcNow - lastSampleTime).TotalMilliseconds > sampleFrequencyMillis)
                {
                    lastSample = counter.NextValue();
                    lastSampleTime = DateTime.UtcNow;
                }
            }
        }

        return lastSample;
    }
}

Ich mochte es nicht, alle PerformanceCounterLösungen im 1-Sekunden-Stall ergänzen zu müssen . Stattdessen habe ich mich für eine WMILösung entschieden. Der Grund für das 1-Sekunden-Warten / Stillstand besteht darin, dass der Messwert bei Verwendung von a genau istPerformanceCounter . Wenn Sie diese Methode jedoch häufig aufrufen und diese Informationen aktualisieren, würde ich raten, diese Verzögerung nicht ständig zu verursachen ... selbst wenn Sie daran denken, einen asynchronen Prozess durchzuführen, um sie abzurufen.

Ich habe mit dem Snippet von hier aus begonnen. Die CPU-Auslastung in WMI mithilfe von C # zurückgeben und eine vollständige Erklärung der Lösung in meinem Blog-Beitrag unten hinzugefügt:

Abrufen der CPU-Auslastung für alle Kerne in C # mithilfe von WMI

public int GetCpuUsage()
{
var cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total", Environment.MachineName);
cpuCounter.NextValue();
System.Threading.Thread.Sleep(1000); //This avoid that answer always 0
return (int)cpuCounter.NextValue();
}

Originalinformationen in diesem Link https://gavindraper.com/2011/03/01/retrieving-accurate-cpu-usage-in-c/