Comment obtenir l'utilisation du processeur en C #?

Je veux obtenir l'utilisation totale totale du processeur pour une application en C #. J'ai trouvé de nombreuses façons de creuser dans les propriétés des processus, mais je ne veux que l'utilisation du processeur des processus et le processeur total comme vous obtenez dans le TaskManager.

Comment je fais ça?

Vous pouvez utiliser la classe PerformanceCounter de System.Diagnostics .

Initialisez comme ceci:

PerformanceCounter cpuCounter;
PerformanceCounter ramCounter;

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

Consommer comme ceci:

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

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

Un peu plus que ce qui était requis, mais j'utilise le code de minuterie supplémentaire pour suivre et alerter si l'utilisation du processeur est de 90% ou plus pendant une période prolongée de 1 minute ou plus.

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

Après avoir passé un peu de temps à lire quelques fils différents qui semblaient assez compliqués, j'ai trouvé cela. J'en avais besoin pour une machine à 8 cœurs où je voulais surveiller le serveur SQL. Pour le code ci-dessous, j'ai passé "sqlservr" comme appName.

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

Il semble mesurer correctement le% de CPU utilisé par SQL sur mon serveur 8 cœurs.

C'est bon, je l'ai! Merci de votre aide!

Voici le code pour le faire:

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

Vous pouvez utiliser WMI pour obtenir des informations sur le pourcentage du processeur. Vous pouvez même vous connecter à un ordinateur distant si vous disposez des autorisations appropriées. Regardez http://www.csharphelp.com/archives2/archive334.html pour avoir une idée de ce que vous pouvez accomplir.

La référence MSDN pour Win32_Process peut également être utile . espace de noms .

Voir aussi un exemple CodeProject Comment: (presque) tout dans WMI via C # .

CMS a raison, mais aussi si vous utilisez l'explorateur de serveurs dans Visual Studio et jouez avec l'onglet du compteur de performances, vous pouvez trouver comment obtenir de nombreuses mesures utiles.

Cela semble fonctionner pour moi, un exemple pour attendre que le processeur atteigne un certain pourcentage

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

Cette classe interroge automatiquement le compteur toutes les 1 secondes et est également thread-safe:

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

Je n'ai pas aimé avoir à ajouter dans le décrochage 1 seconde à toutes les PerformanceCountersolutions. Au lieu de cela, j'ai choisi d'utiliser une WMIsolution. La raison pour laquelle l'attente / décrochage de 1 seconde existe est de permettre à la lecture d'être précise lors de l'utilisation d'unPerformanceCounter . Cependant, si vous appelez souvent cette méthode et actualisez ces informations, je vous conseille de ne pas avoir à subir constamment ce retard ... même si vous envisagez de faire un processus asynchrone pour l'obtenir.

J'ai commencé avec l'extrait d'ici Retour de l'utilisation du processeur dans WMI en utilisant C # et j'ai ajouté une explication complète de la solution sur mon blog ci-dessous:

Obtenir l'utilisation du processeur sur tous les cœurs en C # à l'aide de 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();
}

Informations originales dans ce lien https://gavindraper.com/2011/03/01/retrieving-accurate-cpu-usage-in-c/