PerformanceCounter Classe

Définition

Espace de noms:

System.Diagnostics

Assembly:

System.Diagnostics.PerformanceCounter.dll

Source:

PerformanceCounter.cs

Représente un composant de compteur de performances 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

Héritage

Object

MarshalByRefObject

Component

PerformanceCounter

Implémente

ISupportInitialize

Exemples

L’exemple de code suivant illustre l’utilisation de la PerformanceCounter classe pour créer et utiliser un AverageCount64 type de compteur. L’exemple crée des catégories, configure des compteurs, collecte des données à partir des compteurs et appelle la CounterSampleCalculator classe pour interpréter les données du compteur de performances. Les résultats intermédiaires et finaux sont affichés dans la fenêtre de console. Pour obtenir des exemples supplémentaires d’autres types de compteurs de performances, consultez l’énumération 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

Remarques

Le PerformanceCounter composant peut être utilisé pour lire des compteurs prédéfinis ou personnalisés existants et publier (écrire) des données de performances sur des compteurs personnalisés.

Il existe de nombreux compteurs prédéfinis répertoriés dans la boîte de dialogue Ajouter des compteurs du Moniteur de performances Windows. Pour en savoir plus sur les compteurs de performances .NET Framework, consultez Compteurs de performances.

Ce type implémente l’interface IDisposable . Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement. Pour supprimer directement le type, appelez sa Dispose méthode dans un try/catch bloc. Pour la supprimer indirectement, utilisez une construction de langage telle que using (en C#) ou Using (en Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet implémentant IDisposable » dans la rubrique d’interface IDisposable .

Important

Dans les versions 1.0 et 1.1 de .NET Framework, cette classe nécessite que les appelants immédiats soient entièrement approuvés. À compter de .NET Framework version 2.0, cette classe nécessite PerformanceCounterPermission des actions spécifiques. Il est fortement recommandé de PerformanceCounterPermission ne pas être accordé au code semi-approuvé. La possibilité de lire et d’écrire des compteurs de performances permet au code d’effectuer des actions telles que l’énumération des processus en cours d’exécution et l’obtention d’informations sur ces derniers.

En outre, le passage d’un objet à du PerformanceCounter code moins approuvé peut créer un problème de sécurité. Ne transmettez jamais d’objets de compteur de performances, tels qu’un PerformanceCounterCategory ou PerformanceCounter, à du code moins approuvé.

Pour lire à partir d’un compteur de performances, créez une instance de la PerformanceCounter classe, définissez le CategoryName, CounterNameet, éventuellement, les InstanceNameMachineName propriétés, puis appelez la NextValue méthode pour prendre une lecture de compteur de performances.

Pour publier des données de compteur de performances, créez un ou plusieurs compteurs personnalisés à l’aide de la PerformanceCounterCategory.Create méthode, créez une instance de la PerformanceCounter classe, définissez les CounterNameCategoryNamepropriétés et, éventuellement, InstanceName ou MachineName appelez le IncrementByou IncrementDecrement les méthodes, ou définissez la RawValue propriété pour modifier la valeur de votre compteur personnalisé.

Note

Les Incrementméthodes et Decrement les méthodes IncrementByutilisent des interblocages pour mettre à jour la valeur du compteur. Cela permet de conserver la valeur de compteur exacte dans les scénarios multithreads ou multiprocesseurs, mais entraîne également une pénalité de performances. Si vous n’avez pas besoin de la précision que fournissent les opérations interblocées, vous pouvez mettre à jour la RawValue propriété directement pour une amélioration des performances jusqu’à 5 fois. Toutefois, dans les scénarios multithreads, certaines mises à jour de la valeur du compteur peuvent être ignorées, ce qui entraîne des données inexactes.

Le compteur est le mécanisme par lequel les données de performances sont collectées. Le Registre stocke les noms de tous les compteurs, chacun d’eux étant lié à une zone spécifique de fonctionnalités système. Par exemple, le temps occupé d’un processeur, l’utilisation de la mémoire ou le nombre d’octets reçus via une connexion réseau.

Chaque compteur est identifié de manière unique par son nom et son emplacement. De la même façon qu’un chemin d’accès de fichier inclut un lecteur, un répertoire, un ou plusieurs sous-répertoires et un nom de fichier, les informations du compteur se composent de quatre éléments : l’ordinateur, la catégorie, l’instance de catégorie et le nom du compteur.

Les informations de compteur doivent inclure la catégorie ou l’objet de performance pour lequel le compteur mesure les données. Les catégories d’un ordinateur incluent des composants physiques, tels que des processeurs, des disques et de la mémoire. Il existe également des catégories système, telles que des processus et des threads. Chaque catégorie est liée à un élément fonctionnel au sein de l’ordinateur et a un ensemble de compteurs standard qui lui sont attribués. Ces objets sont répertoriés dans la liste déroulante Des objets performance de la boîte de dialogue Ajouter des compteurs dans l’analyseur système Windows 2000, et vous devez les inclure dans le chemin du compteur. Les données de performances sont regroupées par catégorie à laquelle elles sont associées.

Dans certains cas, plusieurs copies de la même catégorie peuvent exister. Par exemple, plusieurs processus et threads s’exécutent simultanément, et certains ordinateurs contiennent plusieurs processeurs. Les copies de catégorie sont appelées instances de catégorie, et chaque instance a un ensemble de compteurs standard qui lui sont attribués. Si une catégorie peut avoir plusieurs instances, une spécification d’instance doit être incluse dans les informations du compteur.

Pour obtenir des données de performances pour les compteurs nécessitant une valeur initiale ou précédente pour effectuer le calcul nécessaire, appelez la NextValue méthode deux fois et utilisez les informations retournées comme votre application l’exige.

Note

Les catégories de compteurs de performances installées avec .NET utilisent une mémoire partagée distincte, chaque catégorie de compteur de performances ayant sa propre mémoire. Vous pouvez spécifier la taille de la mémoire partagée distincte en créant un fichier DWORD nommé FileMappingSize dans la clé de Registre HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<nom> de catégorie\Performance. La valeur FileMappingSize est définie sur la taille de mémoire partagée de la catégorie. La taille par défaut est 131072 décimale. Si la valeur FileMappingSize n’est pas présente, la fileMappingSize valeur d’attribut de l’élément performanceCounters spécifié dans le fichier Machine.config est utilisée, ce qui entraîne une surcharge supplémentaire pour le traitement du fichier de configuration. Vous pouvez réaliser une amélioration des performances pour le démarrage de l’application en définissant la taille de mappage de fichiers dans le Registre. Pour plus d’informations sur la taille du mappage de fichiers, consultez <performanceCounters>.

Constructeurs

Nom	Description
PerformanceCounter()	Initialise une nouvelle instance en lecture seule de la PerformanceCounter classe, sans associer l’instance à un compteur de performances système ou personnalisé.
PerformanceCounter(String, String, Boolean)	Initialise une nouvelle instance en lecture seule ou en lecture/écriture de la PerformanceCounter classe et l’associe au compteur de performances système ou personnalisé spécifié sur l’ordinateur local. Ce constructeur nécessite que la catégorie contienne une seule instance.
PerformanceCounter(String, String, String, Boolean)	Initialise une nouvelle instance en lecture seule ou en lecture/écriture de la PerformanceCounter classe et l’associe au compteur de performances et à l’instance de catégorie du système ou personnalisé spécifiés sur l’ordinateur local.
PerformanceCounter(String, String, String, String)	Initialise une nouvelle instance en lecture seule de la PerformanceCounter classe et l’associe au compteur de performances et à l’instance de catégorie spécifiées sur l’ordinateur spécifié.
PerformanceCounter(String, String, String)	Initialise une nouvelle instance en lecture seule de la PerformanceCounter classe et l’associe au compteur de performances personnalisé ou au compteur de performances personnalisé et à l’instance de catégorie sur l’ordinateur local.
PerformanceCounter(String, String)	Initialise une nouvelle instance en lecture seule de la PerformanceCounter classe et l’associe au compteur de performances système ou personnalisé spécifié sur l’ordinateur local. Ce constructeur nécessite que la catégorie ait une seule instance.

Champs

Nom	Description
DefaultFileMappingSize	Obsolète. Spécifie la taille, en octets, de la mémoire globale partagée par les compteurs de performances. La taille par défaut est de 524 288 octets.

Propriétés

Nom	Description
CategoryName	Obtient ou définit le nom de la catégorie de compteur de performances pour ce compteur de performances.
CounterHelp	Obtient la description de ce compteur de performances.
CounterName	Obtient ou définit le nom du compteur de performances associé à cette PerformanceCounter instance.
CounterType	Obtient le type de compteur du compteur de performances associé.
InstanceLifetime	Obtient ou définit la durée de vie d’un processus.
InstanceName	Obtient ou définit un nom d’instance pour ce compteur de performances.
MachineName	Obtient ou définit le nom de l’ordinateur pour ce compteur de performances.
RawValue	Obtient ou définit la valeur brute, ou non calculée, de ce compteur.
ReadOnly	Obtient ou définit une valeur indiquant si cette PerformanceCounter instance est en mode lecture seule.

Méthodes

Nom	Description
BeginInit()	Commence l’initialisation d’une PerformanceCounter instance utilisée sur un formulaire ou par un autre composant. L’initialisation se produit au moment de l’exécution.
Close()	Ferme le compteur de performances et libère toutes les ressources allouées par cette instance de compteur de performances.
CloseSharedResources()	Libère l’état partagé de la bibliothèque de compteurs de performances alloué par les compteurs.
Decrement()	Décrémente le compteur de performances associé par un par le biais d’une opération atomique efficace.
EndInit()	Termine l’initialisation d’une PerformanceCounter instance utilisée sur un formulaire ou par un autre composant. L’initialisation se produit au moment de l’exécution.
Increment()	Incrémente le compteur de performances associé d’un par le biais d’une opération atomique efficace.
IncrementBy(Int64)	Incrémente ou décrémente la valeur du compteur de performances associé par une quantité spécifiée par le biais d’une opération atomique efficace.
NextSample()	Obtient un exemple de compteur et retourne la valeur brute, ou non calculée, pour celle-ci.
NextValue()	Obtient un exemple de compteur et retourne la valeur calculée pour celle-ci.
RemoveInstance()	Supprime l’instance de catégorie spécifiée par la propriété d’objet PerformanceCounterInstanceName .

Voir aussi

• PerformanceCounterType
• CounterCreationData
• CounterCreationDataCollection
• CounterSample
• CounterSampleCalculator