web-dev-qa-db-fra.com

Comment obtenir l'utilisation du processeur en C #?

Je souhaite obtenir l'utilisation 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 par les processus, ainsi que le nombre total de processeurs que vous obtenez dans le Gestionnaire des tâches.

Comment je fais ça?

c#cpu-usage
185
Grace

Vous pouvez utiliser la classe PerformanceCounter de System.Diagnostics .

Initialiser comme ceci:

PerformanceCounter cpuCounter;
PerformanceCounter ramCounter;

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

Consommez comme ça:

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

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

Un peu plus que ce qui était demandé mais j’utilise le code de minuterie supplémentaire pour suivre et alerter si l’utilisation du processeur est supérieure ou égale à 90% sur 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";
    }
}
54
Khalid Rahaman

Après avoir passé du temps à lire plusieurs fils différents qui semblaient assez compliqués, je suis arrivé à cette idée. J'en avais besoin pour une machine à 8 cœurs sur laquelle je voulais surveiller le serveur SQL. Pour le code ci-dessous, je suis passé dans "sqlservr" sous le nom 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 pourcentage de CPU utilisé par SQL sur mon serveur 8 core.

20
MtnManChris

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

Vous pouvez utiliser WMI pour obtenir des informations sur le pourcentage de la CPU. 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 de l’espace-noms Win32_Process est également utile.

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

9
adparadox

CMS a tout à fait raison, mais si vous utilisez l'explorateur de serveur dans Visual Studio et que vous jouez avec l'onglet des performances, vous pouvez trouver comment obtenir de nombreux indicateurs utiles.

5
Tarks

Cela semble fonctionner pour moi, un exemple d'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();
}
3
Jay Byford-Rew

Je n'aimais pas avoir à ajouter le décrochage d'une seconde à toutes les solutions PerformanceCounter. Au lieu de cela, j'ai choisi d'utiliser une solution WMI. La raison de l’attente/décrochage d’une seconde existe afin de permettre à la lecture d’être précise lorsqu’on utilise un PerformanceCounter. Cependant, si vous appelez souvent cette méthode et actualisez cette information, je vous conseillerais de ne pas avoir à subir constamment ce délai ... même si vous envisagez de faire un processus asynchrone pour l'obtenir.

J'ai commencé avec l'extrait de code à partir 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 message de blog ci-dessous:

Obtenir l’utilisation du processeur sur tous les cœurs en C # avec WMI

2
atconway

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;
    }
}
1
Colin Breame