Feedback

C# - CPU Last von mehreren CPUs überwachen

Veröffentlicht von am 17.12.2006
(3 Bewertungen)
Mit dieser Klassen kann man die CPU Last von einer oder mehreren CPUs überwachen.

Wichtig: Da diese Klasse die CPUs in eigenen Threads überwacht, muss drauf geachtet werden das wenn man die Werte an die Form übergeben will, man mit Delegates und Invoke arbeiten muss. Ein Beispiel dazu findet man in meinem Kommentar.
GFU-Schulungen  [Anzeige]

XML und .NET Überblick

Um auf dem neuesten Wissensstand zu sein, sollten Sie unser aktuelles ASP .NET Komplett Seminar belegen.
Nach dem Seminar kennen Sie die wichtigsten Strömungen in der Software-Technologie

VB.NET Aufbau

Sie verfügen nach der Schulung über fundierte Kenntnisse in der Arbeit mit objektorientierten Modellen in VB.NET und können wiederverwendbare Komponenten eigenständig erzeugen.

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.Diagnostics;
using System.Threading;

/// <summary>
/// Mit dieser Klassen kann man die CPU Last von einer oder mehreren CPUs überwachen.
/// </summary>
public class CPULoadWatcher
{
    /// <summary>
    /// Dieses Event wird von jedem hinzugefügtem Watcher in den vorgegebenen
    /// Zeitintervallen aufgerufen und übergibt die aktuelle CPU Last.
    /// Hinweis: Der Parameter e wird von einem anderen Thread aus übergeben.
    /// </summary>
    public event CPULoadChangedEventHandler CPULoadChanged;
    public delegate void CPULoadChangedEventHandler(CPULoadEventArgs e);
    private System.Collections.Generic.Dictionary<ushort, Watcher> WatcherCollection = new System.Collections.Generic.Dictionary<ushort, Watcher>();

    /// <summary>
    /// Fügt einen Watcher für eine CPU hinzu
    /// </summary>
    /// <param name="CPU">Die Nummer der CPU die überwacht werden soll</param>
    /// <param name="Interval">Gibt an in welchen Zeitabständen (ms) die CPU Last ausgelesen werden soll. Empfohlen: 1000ms</param>
    public void AddWatcher(ushort CPU, int Interval)
    {
        if (WatcherCollection.ContainsKey(CPU) == false)
        {
            Watcher W = new Watcher(CPU, Interval);
            W.Changed += OnCPULoadChanged;
            WatcherCollection.Add(CPU, W);
            W.Start();
        }
    }

    /// <summary>
    /// Entfernt einen Watcher für eine CPU
    /// </summary>
    /// <param name="CPU">Die Nummer der CPU dessen Watcher entfernt werden soll</param>
    public void RemoveWatcher(ushort CPU)
    {
        if (WatcherCollection.ContainsKey(CPU) == true)
        {
            WatcherCollection[CPU].Abort();
            WatcherCollection.Remove(CPU);
        }
    }

    private void OnCPULoadChanged(CPULoadEventArgs e)
    {
        if (CPULoadChanged != null)
        {
            CPULoadChanged(e);
        }
    }

    private class Watcher
    {
        private ushort mCPU = 0;
        private int mInterval;
        private bool mAbort = false;
        private PerformanceCounter PerfCounter;
        public event ChangedEventHandler Changed;
        public delegate void ChangedEventHandler(CPULoadEventArgs e);

        public Watcher(ushort CPU, int Interval)
        {
            mCPU = CPU;
            mInterval = Interval;
        }

        public void Start()
        {
            PerfCounter = new PerformanceCounter("Processor", "% Processor Time", mCPU.ToString());
            System.Threading.Thread T = new System.Threading.Thread(Watch);
            T.Start();
        }

        public void Abort()
        {
            mAbort = true;
        }

        private void Watch()
        {
            do
            {
                if (mAbort == true)
                {
                    mAbort = false;
                    break;
                }

                if (Changed != null)
                {
                    Changed(new CPULoadEventArgs(mCPU, PerfCounter.NextValue()));
                }
                System.Threading.Thread.Sleep(mInterval);
            }
            while (true);
        }
    }

    public class CPULoadEventArgs
    {
        private ushort mCPU;
        private float mCPULoad;

        public ushort CPU
        {
            get { return mCPU; }
        }

        public float CPULoad
        {
            get { return mCPULoad; }
        }

        public CPULoadEventArgs(ushort CurrCPU, float CurrCPULoad)
        {
            mCPU = CurrCPU;
            mCPULoad = CurrCPULoad;
        }
    }
}
Abgelegt unter CPU, Hardware, Last, Load, Thread.

1 Kommentare zum Snippet

Tim Hartwig schrieb am 17.12.2006:
Hier ein Beispiel für die Anwendung der Klasse mit Delegate und Invoke für einen gültigen Threadübergriff.

private CPULoadWatcher CLW = new CPULoadWatcher();
private delegate void CWLDelegate(CPULoadWatcher.CPULoadEventArgs e);

private void Form1_Load(object sender, EventArgs e)
{
CLW.CPULoadChanged += new CPULoadWatcher.CPULoadChangedEventHandler(CLW_CPULoadChanged);
CLW.AddWatcher(0, 1000);
}

private void CLW_CPULoadChanged(CPULoadWatcher.CPULoadEventArgs e)
{
this.Invoke(new CWLDelegate(ShowValue), new Object[] { e });
}

private void ShowValue(CPULoadWatcher.CPULoadEventArgs e)
{
this.Text = e.CPULoad.ToString();
}
 

Logge dich ein, um hier zu kommentieren!