Come ottenere l'utilizzo della CPU in C #?

Voglio ottenere l'utilizzo totale complessivo della CPU per un'applicazione in C #. Ho trovato molti modi per scavare nelle proprietà dei processi, ma voglio solo l'utilizzo della CPU dei processi e la CPU totale come te nel TaskManager.

Come lo faccio?

È possibile utilizzare la classe PerformanceCounter da System.Diagnostics .

Inizializza in questo modo:

PerformanceCounter cpuCounter;
PerformanceCounter ramCounter;

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

Consuma così:

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

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

Un po 'più di quanto fosse necessario, ma uso il codice timer aggiuntivo per tenere traccia e avvisare se l'utilizzo della CPU è del 90% o superiore per un periodo prolungato di 1 minuto o più.

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

Dopo aver trascorso un po 'di tempo a leggere un paio di thread diversi che sembravano piuttosto complicati, mi sono inventato questo. Ne avevo bisogno per una macchina a 8 core in cui volevo monitorare il server SQL. Per il codice seguente ho passato "sqlservr" come 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);
    }
}

Sembra misurare correttamente la% di CPU utilizzata da SQL sul mio server 8 core.

Va bene, ho capito! Grazie per l'aiuto!

Ecco il codice per farlo:

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

È possibile utilizzare WMI per ottenere informazioni sulla percentuale della CPU. È anche possibile accedere a un computer remoto se si dispone delle autorizzazioni corrette. Guarda http://www.csharphelp.com/archives2/archive334.html per avere un'idea di ciò che puoi realizzare.

Potrebbe essere utile anche il riferimento MSDN per lo spazio dei nomi Win32_Process .

Vedi anche un esempio di CodeProject Come: (quasi) tutto in WMI tramite C # .

CMS ha ragione, ma anche se si utilizza Esplora server in Visual Studio e si gioca con la scheda Contatore delle prestazioni, è possibile capire come ottenere molte metriche utili.

Questo sembra funzionare per me, un esempio per aspettare fino a quando il processore raggiunge una certa percentuale

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

Questa classe esegue automaticamente il polling del contatore ogni 1 secondi ed è anche 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;
    }
}

Non mi è piaciuto dover aggiungere lo stallo di 1 secondo a tutte le PerformanceCountersoluzioni. Invece ho scelto di usare una WMIsoluzione. Il motivo per cui esiste 1 secondo di attesa / stallo è quello di consentire la lettura accurata quando si utilizza a PerformanceCounter. Tuttavia, se chiami spesso questo metodo e aggiorni queste informazioni, ti consiglio di non dover sostenere costantemente questo ritardo ... anche se stai pensando di fare un processo asincrono per ottenerlo.

Ho iniziato con lo snippet da qui Restituendo l'utilizzo della CPU in WMI utilizzando C # e ho aggiunto una spiegazione completa della soluzione sul mio post di blog di seguito:

Ottieni l'utilizzo della CPU in tutti i core in C # usando 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();
}

Informazioni originali in questo link https://gavindraper.com/2011/03/01/retrieving-accurate-cpu-usage-in-c/