PerformanceCounter Classe

Definizione

Spazio dei nomi:

System.Diagnostics

Assembly:

System.Diagnostics.PerformanceCounter.dll

Origine:

PerformanceCounter.cs

Rappresenta un componente del contatore delle prestazioni di Windows NT.

public ref class PerformanceCounter sealed : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize

public sealed class PerformanceCounter : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type PerformanceCounter = class
    inherit Component
    interface ISupportInitialize

Public NotInheritable Class PerformanceCounter
Inherits Component
Implements ISupportInitialize

Ereditarietà

Object

MarshalByRefObject

Component

PerformanceCounter

Implementazioni

ISupportInitialize

Esempio

Nell'esempio di codice seguente viene illustrato l'uso della PerformanceCounter classe per creare e usare un tipo di contatore AverageCount64 . L'esempio crea categorie, configura i contatori, raccoglie i dati dai contatori e chiama la CounterSampleCalculator classe per interpretare i dati del contatore delle prestazioni. I risultati intermedi e finali vengono visualizzati nella finestra della console. Per altri esempi di altri tipi di contatori delle prestazioni, vedere l'enumerazione PerformanceCounterType .

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class App
{
    private static PerformanceCounter avgCounter64Sample;
    private static PerformanceCounter avgCounter64SampleBase;

    public static void Main()
    {
        ArrayList samplesList = new ArrayList();

        // If the category does not exist, create the category and exit.
        // Performance counters should not be created and immediately used.
        // There is a latency time to enable the counters, they should be created
        // prior to executing the application that uses the counters.
        // Execute this sample a second time to use the category.
        if (SetupCategory())
            return;
        CreateCounters();
        CollectSamples(samplesList);
        CalculateResults(samplesList);
    }

    private static bool SetupCategory()
    {
        if ( !PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") )
        {

            CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData averageCount64 = new CounterCreationData();
            averageCount64.CounterType = PerformanceCounterType.AverageCount64;
            averageCount64.CounterName = "AverageCounter64Sample";
            counterDataCollection.Add(averageCount64);

            // Add the base counter.
            CounterCreationData averageCount64Base = new CounterCreationData();
            averageCount64Base.CounterType = PerformanceCounterType.AverageBase;
            averageCount64Base.CounterName = "AverageCounter64SampleBase";
            counterDataCollection.Add(averageCount64Base);

            // Create the category.
            PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
                "Demonstrates usage of the AverageCounter64 performance counter type.",
                PerformanceCounterCategoryType.SingleInstance, counterDataCollection);

            return(true);
        }
        else
        {
            Console.WriteLine("Category exists - AverageCounter64SampleCategory");
            return(false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counters.

        avgCounter64Sample = new PerformanceCounter("AverageCounter64SampleCategory",
            "AverageCounter64Sample",
            false);


        avgCounter64SampleBase = new PerformanceCounter("AverageCounter64SampleCategory",
            "AverageCounter64SampleBase",
            false);

        avgCounter64Sample.RawValue=0;
        avgCounter64SampleBase.RawValue=0;
    }
    private static void CollectSamples(ArrayList samplesList)
    {

        Random r = new Random( DateTime.Now.Millisecond );

        // Loop for the samples.
        for (int j = 0; j < 100; j++)
        {

            int value = r.Next(1, 10);
            Console.Write(j + " = " + value);

            avgCounter64Sample.IncrementBy(value);

            avgCounter64SampleBase.Increment();

            if ((j % 10) == 9)
            {
                OutputSample(avgCounter64Sample.NextSample());
                samplesList.Add( avgCounter64Sample.NextSample() );
            }
            else
            {
                Console.WriteLine();
            }

            System.Threading.Thread.Sleep(50);
        }
    }

    private static void CalculateResults(ArrayList samplesList)
    {
        for(int i = 0; i < (samplesList.Count - 1); i++)
        {
            // Output the sample.
            OutputSample( (CounterSample)samplesList[i] );
            OutputSample( (CounterSample)samplesList[i+1] );

            // Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " +
                CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i],
                (CounterSample)samplesList[i+1]) );

            // Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " +
                MyComputeCounterValue((CounterSample)samplesList[i],
                (CounterSample)samplesList[i+1]) );
        }
    }

    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    //    Description - This counter type shows how many items are processed, on average,
    //        during an operation. Counters of this type display a ratio of the items
    //        processed (such as bytes sent) to the number of operations completed. The
    //        ratio is calculated by comparing the number of items processed during the
    //        last interval to the number of operations completed during the last interval.
    // Generic type - Average
    //      Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number
    //        of items processed during the last sample interval and the denominator (D)
    //        represents the number of operations completed during the last two sample
    //        intervals.
    //    Average (Nx - N0) / (Dx - D0)
    //    Example PhysicalDisk\ Avg. Disk Bytes/Transfer
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
    {
        Single numerator = (Single)s1.RawValue - (Single)s0.RawValue;
        Single denomenator = (Single)s1.BaseValue - (Single)s0.BaseValue;
        Single counterValue = numerator / denomenator;
        return(counterValue);
    }

    // Output information about the counter sample.
    private static void OutputSample(CounterSample s)
    {
        Console.WriteLine("\r\n+++++++++++");
        Console.WriteLine("Sample values - \r\n");
        Console.WriteLine("   BaseValue        = " + s.BaseValue);
        Console.WriteLine("   CounterFrequency = " + s.CounterFrequency);
        Console.WriteLine("   CounterTimeStamp = " + s.CounterTimeStamp);
        Console.WriteLine("   CounterType      = " + s.CounterType);
        Console.WriteLine("   RawValue         = " + s.RawValue);
        Console.WriteLine("   SystemFrequency  = " + s.SystemFrequency);
        Console.WriteLine("   TimeStamp        = " + s.TimeStamp);
        Console.WriteLine("   TimeStamp100nSec = " + s.TimeStamp100nSec);
        Console.WriteLine("++++++++++++++++++++++");
    }
}

Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class App

    Private Shared avgCounter64Sample As PerformanceCounter
    Private Shared avgCounter64SampleBase As PerformanceCounter


    Public Shared Sub Main()

        Dim samplesList As New ArrayList()
        'If the category does not exist, create the category and exit.
        'Performance counters should not be created and immediately used.
        'There is a latency time to enable the counters, they should be created
        'prior to executing the application that uses the counters.
        'Execute this sample a second time to use the counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If

    End Sub

    Private Shared Function SetupCategory() As Boolean
        If Not PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") Then

            Dim counterDataCollection As New CounterCreationDataCollection()

            ' Add the counter.
            Dim averageCount64 As New CounterCreationData()
            averageCount64.CounterType = PerformanceCounterType.AverageCount64
            averageCount64.CounterName = "AverageCounter64Sample"
            counterDataCollection.Add(averageCount64)

            ' Add the base counter.
            Dim averageCount64Base As New CounterCreationData()
            averageCount64Base.CounterType = PerformanceCounterType.AverageBase
            averageCount64Base.CounterName = "AverageCounter64SampleBase"
            counterDataCollection.Add(averageCount64Base)

            ' Create the category.
            PerformanceCounterCategory.Create("AverageCounter64SampleCategory", _
               "Demonstrates usage of the AverageCounter64 performance counter type.", _
                      PerformanceCounterCategoryType.SingleInstance, counterDataCollection)

            Return True
        Else
            Console.WriteLine("Category exists - AverageCounter64SampleCategory")
            Return False
        End If
    End Function 'SetupCategory

    Private Shared Sub CreateCounters()
        ' Create the counters.

        avgCounter64Sample = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64Sample", False)

        avgCounter64SampleBase = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64SampleBase", False)

        avgCounter64Sample.RawValue = 0
        avgCounter64SampleBase.RawValue = 0
    End Sub

    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

        Dim r As New Random(DateTime.Now.Millisecond)

        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99

            Dim value As Integer = r.Next(1, 10)
            Console.Write(j.ToString() + " = " + value.ToString())

            avgCounter64Sample.IncrementBy(value)

            avgCounter64SampleBase.Increment()

            If j Mod 10 = 9 Then
                OutputSample(avgCounter64Sample.NextSample())
                samplesList.Add(avgCounter64Sample.NextSample())
            Else
                Console.WriteLine()
            End If
            System.Threading.Thread.Sleep(50)
        Next j
    End Sub

    Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
        Dim i As Integer
        For i = 0 To (samplesList.Count - 1) - 1
            ' Output the sample.
            OutputSample(CType(samplesList(i), CounterSample))
            OutputSample(CType(samplesList((i + 1)), CounterSample))

            ' Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())

            ' Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
        Next i
    End Sub

    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '	Description - This counter type shows how many items are processed, on average,
    '		during an operation. Counters of this type display a ratio of the items 
    '		processed (such as bytes sent) to the number of operations completed. The  
    '		ratio is calculated by comparing the number of items processed during the 
    '		last interval to the number of operations completed during the last interval. 
    ' Generic type - Average
    '  	Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number 
    '		of items processed during the last sample interval and the denominator (D) 
    '		represents the number of operations completed during the last two sample 
    '		intervals. 
    '	Average (Nx - N0) / (Dx - D0)  
    '	Example PhysicalDisk\ Avg. Disk Bytes/Transfer 
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim numerator As [Single] = CType(s1.RawValue, [Single]) - CType(s0.RawValue, [Single])
        Dim denomenator As [Single] = CType(s1.BaseValue, [Single]) - CType(s0.BaseValue, [Single])
        Dim counterValue As [Single] = numerator / denomenator
        Return counterValue
    End Function 'MyComputeCounterValue

    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
        Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
        Console.WriteLine(("   BaseValue        = " + s.BaseValue.ToString()))
        Console.WriteLine(("   CounterFrequency = " + s.CounterFrequency.ToString()))
        Console.WriteLine(("   CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
        Console.WriteLine(("   CounterType      = " + s.CounterType.ToString()))
        Console.WriteLine(("   RawValue         = " + s.RawValue.ToString()))
        Console.WriteLine(("   SystemFrequency  = " + s.SystemFrequency.ToString()))
        Console.WriteLine(("   TimeStamp        = " + s.TimeStamp.ToString()))
        Console.WriteLine(("   TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
        Console.WriteLine("++++++++++++++++++++++")
    End Sub
End Class

Commenti

Il PerformanceCounter componente può essere usato sia per leggere i contatori predefiniti esistenti che per la pubblicazione (scrittura) dei dati sulle prestazioni in contatori personalizzati.

Nella finestra di dialogo Aggiungi contatori di Windows Performance Monitor sono elencati numerosi contatori predefiniti. Per informazioni sui contatori delle prestazioni di .NET Framework, vedere Contatori delle prestazioni.

Questo tipo implementa l'interfaccia IDisposable . Al termine dell'uso del tipo, è necessario eliminarlo direttamente o indirettamente. Per eliminare direttamente il tipo, chiamare il Dispose relativo metodo in un try/catch blocco. Per eliminarlo indirettamente, usare un costrutto del linguaggio, ad using esempio (in C#) o Using (in Visual Basic). Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nell'argomento relativo all'interfaccia IDisposable .

Importante

Nelle versioni 1.0 e 1.1 di .NET Framework, questa classe richiede che i chiamanti immediati siano completamente attendibili. A partire da .NET Framework versione 2.0, questa classe richiede PerformanceCounterPermission azioni specifiche. È consigliabile PerformanceCounterPermission non concedere codice semi-attendibile. La possibilità di leggere e scrivere contatori delle prestazioni consente al codice di eseguire azioni come l'enumerazione dei processi in esecuzione e l'acquisizione di informazioni su di essi.

Inoltre, il passaggio di un PerformanceCounter oggetto a codice meno attendibile può creare un problema di sicurezza. Non passare mai oggetti contatori delle prestazioni, ad esempio o PerformanceCounterCategoryPerformanceCounter, a codice meno attendibile.

Per leggere da un contatore delle prestazioni, creare un'istanza della PerformanceCounter classe , impostare CategoryName, CounterNamee, facoltativamente, le InstanceName proprietà o MachineName e quindi chiamare il NextValue metodo per eseguire una lettura del contatore delle prestazioni.

Per pubblicare i dati del contatore delle prestazioni, creare uno o più contatori personalizzati usando il PerformanceCounterCategory.Create metodo , creare un'istanza della PerformanceCounter classe , impostare CategoryNamele proprietà , CounterName e, facoltativamente, InstanceName o MachineName , e quindi chiamare i IncrementBymetodi , Incremento Decrement o impostare la RawValue proprietà per modificare il valore del contatore personalizzato.

Annotazioni

I Incrementmetodi , IncrementBye Decrement usano interlock per aggiornare il valore del contatore. Ciò consente di mantenere accurato il valore del contatore negli scenari multithreading o multiprocesso, ma comporta anche una riduzione delle prestazioni. Se non è necessaria l'accuratezza specificata dalle operazioni interlocked, è possibile aggiornare direttamente la RawValue proprietà per un massimo di 5 volte il miglioramento delle prestazioni. Tuttavia, negli scenari multithreading alcuni aggiornamenti al valore del contatore potrebbero essere ignorati, causando dati non accurati.

Il contatore è il meccanismo in base al quale vengono raccolti i dati sulle prestazioni. Il Registro di sistema archivia i nomi di tutti i contatori, ognuno dei quali è correlato a un'area specifica delle funzionalità di sistema. Gli esempi includono il tempo occupato di un processore, l'utilizzo della memoria o il numero di byte ricevuti tramite una connessione di rete.

Ogni contatore viene identificato in modo univoco tramite il nome e la relativa posizione. Nello stesso modo in cui un percorso di file include un'unità, una directory, una o più sottodirectory e un nome file, le informazioni sui contatori sono costituite da quattro elementi: il computer, la categoria, l'istanza di categoria e il nome del contatore.

Le informazioni sul contatore devono includere la categoria o l'oggetto prestazioni per cui il contatore misura i dati. Le categorie di un computer includono componenti fisici, ad esempio processori, dischi e memoria. Esistono anche categorie di sistema, ad esempio processi e thread. Ogni categoria è correlata a un elemento funzionale all'interno del computer e ha un set di contatori standard assegnati. Questi oggetti sono elencati nell'elenco a discesa Oggetto prestazioni della finestra di dialogo Aggiungi contatori all'interno di Monitoraggio di sistema di Windows 2000 ed è necessario includerli nel percorso del contatore. I dati sulle prestazioni vengono raggruppati in base alla categoria a cui è correlata.

In alcuni casi, possono esistere diverse copie della stessa categoria. Ad esempio, diversi processi e thread vengono eseguiti contemporaneamente e alcuni computer contengono più processori. Le copie di categoria sono denominate istanze di categoria e a ogni istanza è assegnato un set di contatori standard. Se una categoria può avere più di un'istanza, è necessario includere una specifica dell'istanza nelle informazioni sul contatore.

Per ottenere i dati sulle prestazioni per i contatori che richiedono un valore iniziale o precedente per eseguire il calcolo necessario, chiamare il NextValue metodo due volte e usare le informazioni restituite come richiesto dall'applicazione.

Annotazioni

Le categorie di contatori delle prestazioni installate con .NET usano memoria condivisa separata, con ogni categoria di contatori delle prestazioni con una propria memoria. È possibile specificare le dimensioni della memoria condivisa separata creando un DWORD denominato FileMappingSize nella chiave del Registro di sistema HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<nome> categoria\Prestazioni. Il valore FileMappingSize viene impostato sulle dimensioni della memoria condivisa della categoria. La dimensione predefinita è 131072 decimale. Se il valore FileMappingSize non è presente, viene utilizzato il fileMappingSize valore dell'attributo per l'elemento specificato nel file Machine.config, causando un sovraccarico aggiuntivo per l'elaborazione performanceCounters dei file di configurazione. È possibile ottenere un miglioramento delle prestazioni per l'avvio dell'applicazione impostando le dimensioni del mapping dei file nel Registro di sistema. Per altre informazioni sulle dimensioni del mapping dei file, vedere <performanceCounters>.

Costruttori

Nome	Descrizione
PerformanceCounter()	Inizializza una nuova istanza di sola lettura della PerformanceCounter classe senza associare l'istanza a un sistema o a un contatore delle prestazioni personalizzato.
PerformanceCounter(String, String, Boolean)	Inizializza una nuova istanza di sola lettura o di lettura/scrittura della PerformanceCounter classe e la associa al sistema specificato o al contatore delle prestazioni personalizzato nel computer locale. Questo costruttore richiede che la categoria contenga una singola istanza.
PerformanceCounter(String, String, String, Boolean)	Inizializza una nuova istanza di sola lettura o di sola lettura/scrittura della PerformanceCounter classe e la associa al sistema specificato o al contatore delle prestazioni personalizzato e all'istanza di categoria nel computer locale.
PerformanceCounter(String, String, String, String)	Inizializza una nuova istanza di sola lettura della PerformanceCounter classe e la associa al sistema specificato o all'istanza di categoria e al contatore delle prestazioni personalizzato nel computer specificato.
PerformanceCounter(String, String, String)	Inizializza una nuova istanza di sola lettura della PerformanceCounter classe e la associa al sistema specificato o al contatore delle prestazioni personalizzato e all'istanza di categoria nel computer locale.
PerformanceCounter(String, String)	Inizializza una nuova istanza di sola lettura della PerformanceCounter classe e la associa al sistema specificato o al contatore delle prestazioni personalizzato nel computer locale. Questo costruttore richiede che la categoria abbia una singola istanza.

Campi

Nome	Descrizione
DefaultFileMappingSize	Obsoleti. Specifica le dimensioni, in byte, della memoria globale condivisa dai contatori delle prestazioni. Le dimensioni predefinite sono 524.288 byte.

Proprietà

Nome	Descrizione
CategoryName	Ottiene o imposta il nome della categoria del contatore delle prestazioni per questo contatore delle prestazioni.
CounterHelp	Ottiene la descrizione per questo contatore delle prestazioni.
CounterName	Ottiene o imposta il nome del contatore delle prestazioni associato a questa PerformanceCounter istanza.
CounterType	Ottiene il tipo di contatore del contatore delle prestazioni associato.
InstanceLifetime	Ottiene o imposta la durata di un processo.
InstanceName	Ottiene o imposta un nome di istanza per questo contatore delle prestazioni.
MachineName	Ottiene o imposta il nome del computer per questo contatore delle prestazioni.
RawValue	Ottiene o imposta il valore non elaborato o non calcolato di questo contatore.
ReadOnly	Ottiene o imposta un valore che indica se questa PerformanceCounter istanza è in modalità di sola lettura.

Metodi

Nome	Descrizione
BeginInit()	Avvia l'inizializzazione di un'istanza utilizzata in una PerformanceCounter maschera o da un altro componente. L'inizializzazione viene eseguita in fase di esecuzione.
Close()	Chiude il contatore delle prestazioni e libera tutte le risorse allocate da questa istanza del contatore delle prestazioni.
CloseSharedResources()	Libera lo stato condiviso della libreria dei contatori delle prestazioni allocato dai contatori.
Decrement()	Decrementa il contatore delle prestazioni associato di uno tramite un'operazione atomica efficiente.
EndInit()	Termina l'inizializzazione di un'istanza PerformanceCounter utilizzata in una maschera o da un altro componente. L'inizializzazione viene eseguita in fase di esecuzione.
Increment()	Incrementa il contatore delle prestazioni associato di uno tramite un'operazione atomica efficiente.
IncrementBy(Int64)	Incrementa o decrementa il valore del contatore delle prestazioni associato in base a una quantità specificata tramite un'operazione atomica efficiente.
NextSample()	Ottiene un campione di contatore e restituisce il valore non elaborato, o non calcolato, per esso.
NextValue()	Ottiene un campione di contatore e restituisce il valore calcolato.
RemoveInstance()	Elimina l'istanza di categoria specificata dalla proprietà dell'oggetto PerformanceCounterInstanceName .

Vedi anche

• PerformanceCounterType
• CounterCreationData
• CounterCreationDataCollection
• CounterSample
• CounterSampleCalculator