loader
Foto

Számítógép teljesítményének monitorozása C# nyelv segítségével

Elkészítünk most C# nyelven egy olyan alkalmazást, amelynek segítségével a számítógépünk memóriáját, processzorának, illetve egyéb perifériájának a teljesítménye követhető nyomon.

Bizonyára már minden Windows operációs rendszert használó olvasó találkozott már a Task Manager-rel (1. ábra), és annak különböző megjelenítési adataival.

kep
1. ábra   Task Manager
 

Nézzük meg, hogy ezeknek a tulajdonságoknak egy részét hogyan tudjuk megjeleníteni egy C# nyelven készített alkalmazással.

Ehhez szükségünk van a PerformanceCounter és a PerformanceCounterCategory oszályokra, illetve a PerformanceCounter osztályban található NextValue metódusra.

Hozzunk létre egy Console projektet (ConsoleTeljesitmeny1) a Visual Studio-val. A PerformmanceCounter osztály használatához szükségünk van a "using System.Diagnostics" szerelvényre.

Az "Program" osztályon belül definiálunk az első programban négy példányt (CPU, ramFree, disk, SYST), amelyeket a Main() metódusban példányosítunk.
A PerformanceCounter osztály példányosításakor hat lehetőség közül választhatunk, ezért láthatunk a négy példány előállításakor különböző konstruktorokat.

Ezután egy eseményt hozunk létre, amely minden 2. másodpercben lefut. Ebben az eseményben írjuk ki a  CPU felhasznált teljesítményét (százalékban), a szabad memória méretét, a sornak a méretét, illetve a logikai disk szabad méretét.

namespace ConsoleTeljesitmeny1
{
    class Program
    {
        public static PerformanceCounter CPU;
        public static PerformanceCounter ramFree;
        public static PerformanceCounter disk;
        public static PerformanceCounter SYST;

        static void Main(string[] args)
        {
            CPU = new PerformanceCounter("Processor", "% Processor Time", "_Total", true);
            ramFree = new PerformanceCounter("Memory", "Available MBytes", true);
            disk = new PerformanceCounter("LogicalDisk", "% Free Space", "_Total");
            SYST = new PerformanceCounter("System", "Processor Queue Length");

            System.Threading.Timer t = new System.Threading.Timer(timerCallBack, null, 0, 2000);

            Console.ReadLine();
        }

        private static void timerCallBack(object state)
        {
            Console.WriteLine(CPU.NextValue() + "\t" + ramFree.NextValue() + "\t" + SYST.NextValue() + "\t" + disk.NextValue());
        }
    }
}

 

Az első program futási eredménye látható a második ábrán.

kep
2. ábra   Futási eredmény
 

A példányosítás egyszerűbben (?) is megoldható, ha a Timer (timerCallBack) eseményében példányosítunk egy paraméternélküli konstruktorral, és ezután a példány property-einek adunk külön-külön értéket.

namespace ConsoleTeljesitmeny1
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Threading.Timer t = new System.Threading.Timer(timerCallBack, null, 0, 2000);

            Console.ReadLine();
        }

        private static void timerCallBack(object state)
        {
            PerformanceCounter pc = new PerformanceCounter();
            pc.CategoryName = "Memory";
            pc.CounterName = "Available MBytes";
            Console.WriteLine("Szabad memória (MB) : {0}", pc.NextValue().ToString());
        }
    }
}

 

A második programmal a szabad memória méretét írjuk ki (3. ábra).

kep
3. ábra   A szabad memória mérete 
 

Felmerülhet a kérdés, hogy a kategóriák neveit (pl.: Processor, Memory, stb) honnan tudhatjuk meg? A harmadik programunk segítségével a különböző kategórianeveket kapjuk meg, amelyeket akár a StreamWriter osztály segítségével file-ba is kiírhatunk.

A PerformanceCounterCategory osztály GetCategories() metódusa visszaadja gyűjteményben a felhasználható Category Name-ket.
Nekünk a foreach ciklussal ezt a gyűjteményt kell bejárnunk. A gyűjtemény tagjainak (item) nem adtunk meg konkrét típust, hanem az anonim típust (var) használtuk fel.

static void Main(string[] args)
        {
            foreach (var item in PerformanceCounterCategory.GetCategories())
            {
                Console.WriteLine(item.CategoryName);
            }

            System.Threading.Timer t = new System.Threading.Timer(timerCallBack, null, 0, 2000);

            Console.ReadLine();
        }

 

Ezzel a programmal ki tudjuk írni a konzolra a számítógépünkön használható kategórianeveket (4. ábra).

kep
4. ábra   Kategóriák nevei (részlet)
 

Végül nézzük meg a hálózatunk terheltségét. Ehhez felhasználjuk a korábban megkapott kategória nevek közül a "Network Interface"-t. Az instance nevek kiírása után (ezek ebben a programban az inName-ben vannak) a gyűjtemény utolsó tagját vizsgáljuk.

class Program
    {
        public static PerformanceCounter NETs;

        static void Main(string[] args)
        {
            PerformanceCounterCategory category = new PerformanceCounterCategory("Network Interface");
            String[] inName = category.GetInstanceNames();

            foreach (var item in inName)
            {
                Console.WriteLine(item);
            }
            NETs = new PerformanceCounter("Network Interface", "Current Bandwidth", inName[1]);

            System.Threading.Timer t = new System.Threading.Timer(timerCallBack, null, 0, 2000);

            Console.ReadLine();
        }

        private static void timerCallBack(object state)
        {
            Console.WriteLine(NETs.NextValue());
        }
    }

 

A "Realtek" értékének megjelenítése az 5. ábrán.

kep
5. ábra   A hálózati kapcsolatok, illetve az aktuális sávszélesség
 

 



Egyéb cikkek

Mappa

További cikkeink ebben a témakörben

Régebbi cikkeink

Ebben a cikkben megismerjük a C# nyelv által használt változók nagy részét. Nézünk egy példát a típuskonverzióra.. . . .

Ebben a cikkben bemutatjuk a metódusok alapjait. Nem érintjük viszont például a túlterhelést, ezt egy következő részben tekintjük át.. . . .

Ebben a cikkben nem csak a metódusok túlterhelését nézzük meg egy konkrét példa segítségével, hanem szóba kerülnek a generikusok is, szintén egy kisebb projekt keretén belül.. . . .