PerformanceCounterCategory Classe

Définition

Espace de noms:

System.Diagnostics

Assembly:

System.Diagnostics.PerformanceCounter.dll

Paquet:

System.Diagnostics.PerformanceCounter v8.0.0

Source:

PerformanceCounterCategory.cs

Représente un objet de performance qui définit une catégorie de compteurs de performance.

public ref class PerformanceCounterCategory sealed

public sealed class PerformanceCounterCategory

type PerformanceCounterCategory = class

Public NotInheritable Class PerformanceCounterCategory

Héritage

Object

PerformanceCounterCategory

Exemples

L’exemple de code suivant détermine si un PerformanceCounter et son PerformanceCounterCategory existent sur l’ordinateur local ou sur un autre ordinateur. Si ces objets n’existent pas sur l’ordinateur local, l’exemple les crée éventuellement. Il utilise la Exists méthode pour déterminer si le PerformanceCounterCategory existe. Si le PerformanceCounterCategory n’existe pas et qu’aucun nom de compteur n’est spécifié, ou si l’ordinateur est un ordinateur distant, l’exemple se ferme.

Si un PerformanceCounter nom est fourni, l’exemple utilise la CounterExists méthode et affiche le résultat à l’utilisateur. Si le PerformanceCounter n’existe pas, l’utilisateur peut supprimer et recréer le PerformanceCounterCategory avec le nouveau PerformanceCounter. Si l’utilisateur le fait, la catégorie est supprimée à l’aide de la Delete méthode .

Si vous le demande, l’exemple crée maintenant le nouveau PerformanceCounterCategory et PerformanceCounter à l’aide de la Create méthode . Si un nom de instance est spécifié, l’exemple utilise la InstanceExists méthode et affiche le résultat.

using System;
using System.Diagnostics;
using Microsoft.VisualBasic;

class PerfCounterCatCreateExistMod
{

    public static void Main(string[] args)
    {
        string categoryName = "";
        string counterName = "";
        string instanceName = "";
        string machineName = "";
        string categoryHelp = "";
        string counterHelp = "";
        bool objectExists = false;
        PerformanceCounterCategory pcc;
        bool createCategory = false;

        // Copy the supplied arguments into the local variables.
        try
        {
            categoryName = args[0];
            counterName = args[1];
            instanceName = args[2];
            machineName = args[3]=="."? "": args[3];
            categoryHelp = args[4];
            counterHelp = args[5];
        }
        catch(Exception ex)
        {
            // Ignore the exception from non-supplied arguments.
        }

        // Verify that the category name is not blank.
        if (categoryName.Length==0)
        {
            Console.WriteLine("Category name cannot be blank.");
            return;
        }

        // Check whether the specified category exists.
        if (machineName.Length==0)
        {
            objectExists = PerformanceCounterCategory.Exists(categoryName);

        }
        else
        {
            // Handle the exception that is thrown if the computer
            // cannot be found.
            try
            {
                objectExists = PerformanceCounterCategory.Exists(categoryName, machineName);
            }
            catch(Exception ex)
            {
                Console.WriteLine("Error checking for existence of " +
                    "category \"{0}\" on computer \"{1}\":"+"\n" +ex.Message, categoryName, machineName);
                return;
            }
        }

        // Tell the user whether the specified category exists.
        Console.WriteLine("Category \"{0}\" "+ (objectExists? "exists on ": "does not exist on ")+
            (machineName.Length>0? "computer \"{1}\".": "this computer."), categoryName, machineName);

        // If no counter name is given, the program cannot continue.
        if (counterName.Length==0)
        {
            return;
        }

        // A category can only be created on the local computer.
        if (!objectExists)
        {
            if (machineName.Length>0)
            {
                return;
            }
            else
            {
                createCategory = true;
            }
        }
        else
        {
            // Check whether the specified counter exists.
            if (machineName.Length==0)
            {
                objectExists = PerformanceCounterCategory.CounterExists(counterName, categoryName);
            }
            else
            {
                objectExists = PerformanceCounterCategory.CounterExists(counterName, categoryName, machineName);
            }

            // Tell the user whether the counter exists.
            Console.WriteLine("Counter \"{0}\" "+(objectExists? "exists": "does not exist")+
                " in category \"{1}\" on "+(machineName.Length>0? "computer \"{2}\".": "this computer."),
                counterName, categoryName, machineName);

            // If the counter does not exist, consider creating it.
            if (!objectExists)

                // If this is a remote computer,
                // exit because the category cannot be created.
            {
                if (machineName.Length>0)
                {
                    return;
                }
                else
                {
                    // Ask whether the user wants to recreate the category.
                    Console.Write("Do you want to delete and recreate " +
                        "category \"{0}\" with your new counter? [Y/N]: ", categoryName);
                    string userReply = Console.ReadLine();

                    // If yes, delete the category so it can be recreated later.
                    if (userReply.Trim().ToUpper()=="Y")
                    {
                        PerformanceCounterCategory.Delete(categoryName);
                        createCategory = true;
                    }
                    else
                    {
                        return;
                    }
                }
            }
        }

        // Create the category if it was deleted or it never existed.
        if (createCategory)
        {
            pcc = PerformanceCounterCategory.Create(categoryName, categoryHelp, counterName, counterHelp);

            Console.WriteLine("Category \"{0}\" with counter \"{1}\" created.", pcc.CategoryName, counterName);
        }
        else if(instanceName.Length>0)
        {
            if (machineName.Length==0)
            {
                objectExists = PerformanceCounterCategory.InstanceExists(instanceName, categoryName);
            }
            else
            {
                objectExists = PerformanceCounterCategory.InstanceExists(instanceName, categoryName, machineName);
            }

            // Tell the user whether the instance exists.
            Console.WriteLine("Instance \"{0}\" "+(objectExists? "exists": "does not exist")+
                " in category \"{1}\" on " + (machineName.Length>0? "computer \"{2}\".": "this computer."),
                instanceName, categoryName, machineName);
        }
    }
}

Imports System.Diagnostics

Module PerfCounterCatCreateExistMod

    Sub Main(ByVal args() As String)
        Dim categoryName As String = ""
        Dim counterName As String = ""
        Dim instanceName As String = ""
        Dim machineName As String = ""
        Dim categoryHelp As String = ""
        Dim counterHelp As String = ""
        Dim objectExists As Boolean = False
        Dim pcc As PerformanceCounterCategory
        Dim createCategory As Boolean = False

        ' Copy the supplied arguments into the local variables.
        Try
            categoryName = args(0)
            counterName = args(1)
            instanceName = args(2)
            machineName = IIf(args(3) = ".", "", args(3))
            categoryHelp = args(4)
            counterHelp = args(5)
        Catch ex As Exception
            ' Ignore the exception from non-supplied arguments.
        End Try

        ' Verify that the category name is not blank.
        If categoryName.Length = 0 Then
            Console.WriteLine("Category name cannot be blank.")
            Return
        End If

        ' Check whether the specified category exists.
        If machineName.Length = 0 Then
            objectExists = _
                PerformanceCounterCategory.Exists(categoryName)

        Else
            ' Handle the exception that is thrown if the computer 
            ' cannot be found.
            Try
                objectExists = PerformanceCounterCategory.Exists( _
                    categoryName, machineName)
            Catch ex As Exception
                Console.WriteLine("Error checking for existence of " & _
                    "category ""{0}"" on computer ""{1}"":" & vbCrLf & _
                    ex.Message, categoryName, machineName)
                Return
            End Try
        End If

        ' Tell the user whether the specified category exists.
        Console.WriteLine("Category ""{0}"" " & _
            IIf(objectExists, "exists on ", "does not exist on ") & _
            IIf(machineName.Length > 0, _
                "computer ""{1}"".", "this computer."), _
            categoryName, machineName)

        ' If no counter name is given, the program cannot continue.
        If counterName.Length = 0 Then
            Return
        End If

        ' A category can only be created on the local computer.
        If Not objectExists Then
            If machineName.Length > 0 Then
                Return
            Else
                createCategory = True
            End If
        Else
            ' Check whether the specified counter exists.
            If machineName.Length = 0 Then
                objectExists = PerformanceCounterCategory.CounterExists( _
                    counterName, categoryName)
            Else
                objectExists = PerformanceCounterCategory.CounterExists( _
                    counterName, categoryName, machineName)
            End If

            ' Tell the user whether the counter exists.
            Console.WriteLine("Counter ""{0}"" " & _
                IIf(objectExists, "exists", "does not exist") & _
                " in category ""{1}"" on " & _
                IIf(machineName.Length > 0, _
                    "computer ""{2}"".", "this computer."), _
                counterName, categoryName, machineName)

            ' If the counter does not exist, consider creating it.
            If Not objectExists Then

                ' If this is a remote computer, 
                ' exit because the category cannot be created.
                If machineName.Length > 0 Then
                    Return
                Else
                    ' Ask whether the user wants to recreate the category.
                    Console.Write("Do you want to delete and recreate " & _
                        "category ""{0}"" with your new counter? [Y/N]: ", _
                        categoryName)
                    Dim userReply As String = Console.ReadLine()

                    ' If yes, delete the category so it can be recreated later.
                    If userReply.Trim.ToUpper.Chars(0) = "Y" Then
                        PerformanceCounterCategory.Delete(categoryName)
                        createCategory = True
                    Else
                        Return
                    End If
                End If
            End If
        End If

        ' Create the category if it was deleted or it never existed.
        If createCategory Then
            pcc = PerformanceCounterCategory.Create( _
                categoryName, categoryHelp, counterName, counterHelp)

            Console.WriteLine( _
                "Category ""{0}"" with counter ""{1}"" created.", _
                pcc.CategoryName, counterName)

        ElseIf instanceName.Length > 0 Then

            ' If an instance name was given, check whether it exists.
            If machineName.Length = 0 Then
                objectExists = PerformanceCounterCategory.InstanceExists( _
                    instanceName, categoryName)
            Else
                objectExists = PerformanceCounterCategory.InstanceExists( _
                    instanceName, categoryName, machineName)
            End If

            ' Tell the user whether the instance exists.
            Console.WriteLine("Instance ""{0}"" " & _
                IIf(objectExists, "exists", "does not exist") & _
                " in category ""{1}"" on " & _
                IIf(machineName.Length > 0, _
                    "computer ""{2}"".", "this computer."), _
                instanceName, categoryName, machineName)
        End If
    End Sub
End Module

Remarques

Important

La création ou la suppression d’un compteur de performances nécessite la synchronisation du code sous-jacent à l’aide d’un mutex nommé. Si une application hautement privilégiée verrouille le mutex nommé, les tentatives de création ou de suppression d’un compteur de performances entraînent l’arrêt de la réponse de l’application jusqu’à ce que le verrou soit libéré. Pour éviter ce problème, n’accordez UnmanagedCode jamais d’autorisation à du code non approuvé. En outre, l’autorisation UnmanagedCode permet potentiellement de contourner d’autres autorisations et ne doit être accordée qu’à du code hautement fiable.

La PerformanceCounterCategory propriété du CategoryName instance s’affiche dans le champ Objet de performance de la boîte de dialogue Ajouter un compteur de l’application Visionneuse de performances.

La PerformanceCounterCategory classe fournit plusieurs méthodes pour interagir avec les compteurs et les catégories sur l’ordinateur. Les Create méthodes vous permettent de définir des catégories personnalisées. La Delete méthode permet de supprimer des catégories de l’ordinateur. La GetCategories méthode vous permet d’afficher la liste des catégories, tout en récupérant ReadCategory toutes les données de compteur et de instance associées à une seule catégorie.

Un compteur de performances publie des données de performances sur une application. Les catégories incluent les composants physiques (tels que les processeurs, les disques et la mémoire) et les objets système (tels que les processus et les threads). Les compteurs système qui sont liés au même objet de performances sont regroupés dans une catégorie qui indique leur focus commun. Lorsque vous créez un instance de la PerformanceCounter classe, vous indiquez d’abord la catégorie avec laquelle le composant interagira, puis vous choisissez un compteur dans cette catégorie.

Par exemple, une catégorie de compteurs Windows est la catégorie Mémoire. Les compteurs système de cette catégorie suivent les données de mémoire telles que le nombre d’octets disponibles et le nombre d’octets mis en cache. Si vous souhaitez utiliser les octets mis en cache dans votre application, vous devez créer un instance du composant, le PerformanceCounter connecter à la catégorie Mémoire, puis sélectionner le compteur approprié (dans ce cas, octets mis en cache) dans cette catégorie.

Bien que votre système rend de nombreuses catégories de compteurs disponibles, les catégories avec lesquelles vous interagirez probablement le plus fréquemment sont les catégories Cache, Mémoire, Objets, PhysicalDisk, Process, Processor, Server, System et Thread.

Important

La RemoveInstance méthode de la PerformanceCounter classe libère le compteur et, si l’option de réutilisation est sélectionnée pour cette catégorie, la instance du compteur est réutilisée. Cela peut entraîner une condition de concurrence si un autre processus ou même une autre partie du code tente d’écrire dans le compteur instance.

Notes

Il est vivement recommandé de créer de nouvelles catégories de compteurs de performances pendant l’installation de l’application, et non pendant l’exécution de l’application. Cela laisse le temps au système d’exploitation d’actualiser sa liste de catégories de compteurs de performances inscrites. Si la liste n’a pas été actualisée, la tentative d’utilisation de la catégorie échoue.

Notes

Les catégories de compteurs de performances installées avec .NET Framework 2.0 utilisent une mémoire partagée distincte, chaque catégorie de compteurs de performances ayant sa propre mémoire. Vous pouvez spécifier la taille de la mémoire partagée distincte en créant un 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écimal. 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 des fichiers de configuration. Vous pouvez réaliser une amélioration des performances pour le démarrage de l’application en définissant la taille du mappage de fichiers dans le Registre. Pour plus d’informations sur la taille du mappage de fichiers, consultez <performanceCounters>.

Constructeurs

PerformanceCounterCategory()	Initialise une nouvelle instance de la classe PerformanceCounterCategory, laisse la propriété CategoryName vide et affecte l'ordinateur local comme valeur de la propriété MachineName.
PerformanceCounterCategory(String)	Initialise une nouvelle instance de la classe PerformanceCounterCategory, affecte à la propriété CategoryName la valeur spécifiée et affecte l'ordinateur local comme valeur de la propriété MachineName.
PerformanceCounterCategory(String, String)	Initialise une nouvelle instance de la classe PerformanceCounterCategory et affecte aux propriétés CategoryName et MachineName les valeurs spécifiées.

Propriétés

CategoryHelp	Obtient le texte d'aide de la catégorie.
CategoryName	Obtient ou définit le nom de l'objet de performance qui définit cette catégorie.
CategoryType	Obtient le type de catégorie du compteur de performance.
MachineName	Obtient ou définit le nom de l'ordinateur sur lequel réside cette catégorie.

Méthodes

CounterExists(String)	Détermine si le compteur spécifié est inscrit dans cette catégorie, qui est indiquée par les propriétés CategoryName et MachineName.
CounterExists(String, String)	Détermine si le compteur spécifié est inscrit dans la catégorie donnée de l'ordinateur local.
CounterExists(String, String, String)	Détermine si le compteur spécifié est inscrit dans la catégorie donnée d'un ordinateur distant.
Create(String, String, CounterCreationDataCollection)	Obsolète. Inscrit la catégorie de compteurs de performance personnalisée qui contient les compteurs spécifiés de l'ordinateur local.
Create(String, String, PerformanceCounterCategoryType, CounterCreationDataCollection)	Inscrit la catégorie de compteurs de performance personnalisée qui contient les compteurs spécifiés de l'ordinateur local.
Create(String, String, PerformanceCounterCategoryType, String, String)	Inscrit la catégorie de compteurs de performance personnalisée contenant un seul compteur de type NumberOfItems32 situé sur l'ordinateur local.
Create(String, String, String, String)	Obsolète. Inscrit une catégorie de compteurs de performance personnalisée contenant un seul compteur de type NumberOfItems32 situé sur l'ordinateur local.
Delete(String)	Supprime de l'ordinateur local la catégorie et les compteurs qui lui sont associés.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
Exists(String)	Détermine si la catégorie est inscrite sur l'ordinateur local.
Exists(String, String)	Détermine si la catégorie est inscrite sur l'ordinateur spécifié.
GetCategories()	Récupère la liste des catégories de compteurs de performance inscrites sur l'ordinateur local.
GetCategories(String)	Récupère la liste des catégories de compteurs de performance inscrites sur l'ordinateur spécifié.
GetCounters()	Récupère la liste des compteurs d'une catégorie de compteurs de performance qui contient exactement une seule instance.
GetCounters(String)	Récupère la liste des compteurs d'une catégorie de compteurs de performance qui contient une ou plusieurs instances.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetInstanceNames()	Récupère la liste des instances de l'objet de performance associées à cette catégorie.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
InstanceExists(String)	Détermine si l'instance spécifiée de l'objet de performance existe dans la catégorie identifiée par la propriété PerformanceCounterCategory de cet objet CategoryName.
InstanceExists(String, String)	Détermine si une catégorie spécifiée de l'ordinateur local contient l'instance donnée de l'objet de performance.
InstanceExists(String, String, String)	Détermine si une catégorie spécifiée d'un ordinateur donné contient l'instance déterminée de l'objet de performance.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ReadCategory()	Lit toutes les données de l'instance de l'objet de compteur et de performance associées à cette catégorie de compteurs de performance.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Voir aussi

• PerformanceCounter
• CounterCreationDataCollection
• CounterSample