Performance Counters: Creiamo i nostri primi perfCounters con C#

Nel precedente articolo, abbiamo visto cosa sono e come si creano tramite i tools di microsoft i performance counters. Oggi vediamo come creare da codice ed utilizzare i nostri perfCounter nei nostri progetti: creeremo dei performance counter per monitorare le informazioni principali del nostro server: CPU, Memoria, processi usati, etc.

In questo esempio vedremo come utilizzare e reperire alcune informazioni di stato della macchina : CPU, MEMORIA,  PAGING FILE, creando anche una piccola dashboard per poterli visualizzare. Ecco il codice sorgente:

per prima cosa dobbiamo instanziare la libreria System.Diagnostics

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net.NetworkInformation;
using System.Text;

namespace SysCounters
{
public class PerformanceCounters
{
private string machineName = System.Environment.MachineName;

private PerformanceCounter _cpuPerfCounter = null;
private PerformanceCounter _ramPerfCounter = null;
private PerformanceCounter _pagePerfCounter = null;
private PerformanceCounter[] _nicPerfCounter = null;

#region properties
public PerformanceCounter CpuPerfCounter
{
get { return _cpuPerfCounter; }
set { _cpuPerfCounter = value; }
}

public PerformanceCounter RamPerfCounter
{
get { return _ramPerfCounter; }
set { _ramPerfCounter = value; }
}

public PerformanceCounter PagePerfCounter
{
get { return _pagePerfCounter; }
set { _pagePerfCounter = value; }
}

public PerformanceCounter[] NicPerfCounter
{
get { return _nicPerfCounter; }
set { _nicPerfCounter = value; }
}
#endregion

#region public
public void InizializePerfCounters()
{
try
{
CpuPerfCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total", machineName);
//ramCounter = new PerformanceCounter("Memory", "Available MBytes", String.Empty, machineName);
RamPerfCounter = new PerformanceCounter("Memory", "% Committed Bytes In Use", String.Empty, machineName);
PagePerfCounter = new PerformanceCounter("Paging File", "% Usage", "_Total", machineName);
// there can be multiple network interfaces
NicPerfCounter = GetNICCounters();
}
catch (Exception ex)
{
throw new Exception(String.Format("Unable to access computer '{0}'\r\nPlease check spelling and verify this computer is connected to the network", this.machineName));
}
}

public void DisposePerfCounters()
{
try
{
// dispose of the counters
if (CpuPerfCounter != null)
{ CpuPerfCounter.Dispose(); }
if (RamPerfCounter != null)
{ RamPerfCounter.Dispose(); }
if (PagePerfCounter != null)
{ PagePerfCounter.Dispose(); }
if (NicPerfCounter != null)
{
foreach (PerformanceCounter counter in NicPerfCounter)
{ counter.Dispose(); }
}
}
finally
{ PerformanceCounter.CloseSharedResources(); }
}

// machinename defaults to local computer, but we can
// specify remote computer to monitor as well via command line param
public void GetMachineName()
{
string[] cmdArgs = System.Environment.GetCommandLineArgs();
if ((cmdArgs != null) && (cmdArgs.Length > 1))
{ this.machineName = cmdArgs[1]; }
}

// ping the remote computer
public bool VerifyRemoteMachineStatus(string machineName)
{
try
{
using (Ping ping = new Ping())
{
PingReply reply = ping.Send(machineName);
if (reply.Status == IPStatus.Success)
{ return true; }
}
}
catch (Exception ex)
{
// return false for any exception encountered
// we'll probably want to just shut down anyway
}
return false;
}

// machine can have multiple nic cards (and laptops usually have wifi & wired)
// don't want to get into figuring out which one to show, just get all
// can enumerate network card other ways (System.Net.NetworkInformation)

// PerformanceCounters can return string[] of available network interfaces
public string[] GetNICInstances(string machineName)
{
string filter = "MS TCP Loopback interface";
List<string> nics = new List<string>();
PerformanceCounterCategory category = new PerformanceCounterCategory("Network Interface", machineName);
if (category.GetInstanceNames() != null)
{
foreach (string nic in category.GetInstanceNames())
{
if (!nic.Equals(filter, StringComparison.InvariantCultureIgnoreCase))
{ nics.Add(nic); }
}
}
return nics.ToArray();
}

// create a Performance Counter for each network interface
public PerformanceCounter[] GetNICCounters()
{
string[] nics = GetNICInstances(this.machineName);
List<PerformanceCounter> nicCounters = new List<PerformanceCounter>();
foreach (string nicInstance in nics)
{
nicCounters.Add(new PerformanceCounter("Network Interface", "Bytes Total/sec", nicInstance, this.machineName));
}
return nicCounters.ToArray();
}

#endregion

}
}

Questo e’ il link  a github per scaricare la classe.

Questa classe e’ utilizzata per implementare ed inizializzare i vari performance counters. Ora non si fara’ altro che inizializzare e richiamare la classe, magari da una dashborad asp.net, wpf o winform e il gioco e’ fatto. Nei prossimi posts vedremo come poter utilizzare WPF per creare una semplice dashboard per visualizzare i nostri dati.

Ringrazio questo articolo che mi ha aiutato a capire e a creare i miei performance Counters, dove ho preso spunto per creare il codice che ho postato.

One thought on “Performance Counters: Creiamo i nostri primi perfCounters con C#

  1. Pingback: Performance Counters: Introduzione « Cose inutili ma utili…

Lascia un commento

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione / Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione / Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione / Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione / Modifica )

Connessione a %s...