PerformanceCounterCategory Classe

Definizione

Spazio dei nomi:

System.Diagnostics

Assembly:

System.Diagnostics.PerformanceCounter.dll

Pacchetto:

System.Diagnostics.PerformanceCounter v8.0.0

Source:

PerformanceCounterCategory.cs

Rappresenta un oggetto delle prestazioni, che definisce una categoria di contatori delle prestazioni.

public ref class PerformanceCounterCategory sealed

public sealed class PerformanceCounterCategory

type PerformanceCounterCategory = class

Public NotInheritable Class PerformanceCounterCategory

Ereditarietà

Object

PerformanceCounterCategory

Esempio

Nell'esempio di codice seguente viene determinato se un PerformanceCounter oggetto e il relativo PerformanceCounterCategory esistente nel computer locale o in un altro computer. Se questi oggetti non esistono nel computer locale, l'esempio li crea facoltativamente. Usa il Exists metodo per determinare se esiste PerformanceCounterCategory . Se non PerformanceCounterCategory esiste e non viene specificato alcun nome del contatore oppure se il computer è un computer remoto, l'esempio viene chiuso.

Se viene specificato un PerformanceCounter nome, nell'esempio viene usato il metodo e viene visualizzato il CounterExists risultato all'utente. Se l'oggetto PerformanceCounter non esiste, l'utente può eliminare e ricreare l'oggetto PerformanceCounterCategory con il nuovo PerformanceCounteroggetto . Se l'utente lo fa, la categoria viene eliminata usando il Delete metodo .

Se richiesto, l'esempio crea ora il nuovo PerformanceCounterCategory e PerformanceCounter usando il Create metodo . Se viene specificato un nome di istanza, nell'esempio viene usato il InstanceExists metodo e viene visualizzato il risultato.

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

Commenti

Importante

La creazione o l'eliminazione di un contatore delle prestazioni richiede la sincronizzazione del codice sottostante usando un mutex denominato. Se un'applicazione con privilegi elevati blocca il mutex denominato, tenta di creare o eliminare un contatore delle prestazioni causa l'arresto della risposta dell'applicazione fino al rilascio del blocco. Per evitare questo problema, non concedere UnmanagedCode mai l'autorizzazione al codice non attendibile. Inoltre, UnmanagedCode l'autorizzazione consente di ignorare altre autorizzazioni e deve essere concessa solo al codice altamente attendibile.

La PerformanceCounterCategory proprietà dell'istanza CategoryName viene visualizzata nel campo Oggetto prestazioni della finestra di dialogo Aggiungi contatore dell'applicazione Performance Viewer.

La PerformanceCounterCategory classe fornisce diversi metodi per interagire con contatori e categorie nel computer. I Create metodi consentono di definire categorie personalizzate. Il Delete metodo consente di rimuovere le categorie dal computer. Il GetCategories metodo consente di visualizzare l'elenco di categorie, recuperando ReadCategory tutti i dati del contatore e dell'istanza associati a una singola categoria.

Un contatore delle prestazioni pubblica i dati sulle prestazioni relativi a un'applicazione. Le categorie includono componenti fisici ( ad esempio processori, dischi e memoria) e oggetti di sistema (ad esempio processi e thread). I contatori di sistema correlati allo stesso oggetto prestazioni vengono raggruppati in una categoria che indica lo stato attivo comune. Quando si crea un'istanza PerformanceCounter della classe, si indica innanzitutto la categoria con cui il componente interagisce e quindi si sceglie un contatore da tale categoria.

Ad esempio, una categoria di contatore di Windows è la categoria Memoria. I contatori di sistema all'interno di questa categoria tengono traccia dei dati di memoria, ad esempio il numero di byte disponibili e il numero di byte memorizzati nella cache. Se si desidera usare i byte memorizzati nella cache nell'applicazione, si creerebbe un'istanza del PerformanceCounter componente, connetterla alla categoria Memoria e quindi selezionare il contatore appropriato (in questo caso, Byte memorizzati nella cache) da tale categoria.

Anche se il sistema rende disponibili molte più categorie di contatori, le categorie con cui probabilmente si interagisce più frequentemente sono le categorie Cache, Memory, Objects, PhysicalDisk, Process, Processor, Server, System e Thread.

Importante

Il RemoveInstance metodo nella PerformanceCounter classe rilascia il contatore e, se l'opzione di riutilizzo è selezionata per tale categoria, l'istanza del contatore verrà riutilizzata. Ciò potrebbe causare una condizione di gara se un altro processo o anche un'altra parte del codice sta tentando di scrivere nell'istanza del contatore.

Nota

È consigliabile creare nuove categorie di contatori delle prestazioni durante l'installazione dell'applicazione, non durante l'esecuzione dell'applicazione. Ciò consente al sistema operativo di aggiornare l'elenco delle categorie di contatori delle prestazioni registrate. Se l'elenco non è stato aggiornato, il tentativo di usare la categoria avrà esito negativo.

Nota

Le categorie di contatori delle prestazioni installate con .NET Framework 2.0 usano memoria condivisa separata, con ogni categoria di contatore delle prestazioni che ha la propria memoria. È possibile specificare le dimensioni della memoria condivisa separata creando una DWORD denominata FileMappingSize nella chiave del Registro di sistema HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<nome> categoria\Prestazioni. Il valore FileMappingSize è impostato sulla dimensione della memoria condivisa della categoria. La dimensione predefinita è 131072 decimale. Se il valore FileMappingSize non è presente, viene usato il fileMappingSize valore dell'attributo per l'elemento specificato nel file di Machine.config, causando un sovraccarico aggiuntivo per l'elaborazione performanceCounters dei file di configurazione. È possibile realizzare 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

PerformanceCounterCategory()	Consente di inizializzare una nuova istanza della classe PerformanceCounterCategory, lascia vuota la proprietà CategoryName e imposta la proprietà MachineName sul computer locale.
PerformanceCounterCategory(String)	Consente di inizializzare una nuova istanza della classe PerformanceCounterCategory, imposta la proprietà CategoryName sul valore specificato e la proprietà MachineName sul computer locale.
PerformanceCounterCategory(String, String)	Consente di inizializzare una nuova istanza della classe PerformanceCounterCategory e imposta le proprietà CategoryName e MachineName sui valori specificati.

Proprietà

CategoryHelp	Ottiene il testo della Guida della categoria.
CategoryName	Ottiene o imposta il nome dell'oggetto delle prestazioni che definisce questa categoria.
CategoryType	Ottiene il tipo di categoria del contatore delle prestazioni.
MachineName	Ottiene o imposta il nome del computer sul quale è presente questa categoria.

Metodi

CounterExists(String)	Determina se il contatore specificato è registrato in questa categoria, indicata dalle proprietà CategoryName e MachineName.
CounterExists(String, String)	Determina se il contatore specificato è registrato nella categoria specificata sul computer locale.
CounterExists(String, String, String)	Determina se il contatore specificato è registrato nella categoria specificata in un computer remoto.
Create(String, String, CounterCreationDataCollection)	Obsoleti. Registra la categoria personalizzata di contatori delle prestazioni contenente i contatori specificati sul computer locale.
Create(String, String, PerformanceCounterCategoryType, CounterCreationDataCollection)	Registra la categoria personalizzata di contatori delle prestazioni contenente i contatori specificati sul computer locale.
Create(String, String, PerformanceCounterCategoryType, String, String)	Registra la categoria personalizzata di contatori delle prestazioni contenente un solo contatore di tipo NumberOfItems32 sul computer locale.
Create(String, String, String, String)	Obsoleti. Registra una categoria personalizzata di contatori delle prestazioni contenente un solo contatore di tipo NumberOfItems32 sul computer locale.
Delete(String)	Rimuove la categoria e i contatori associati dal computer locale.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Exists(String)	Determina se la categoria è registrata sul computer locale.
Exists(String, String)	Determina se la categoria è registrata sul computer specificato.
GetCategories()	Recupera un elenco di categorie di contatori delle prestazioni registrate sul computer locale.
GetCategories(String)	Recupera un elenco di categorie di contatori delle prestazioni registrate sul computer specificato.
GetCounters()	Recupera un elenco di contatori in una categoria di contatori delle prestazioni che contiene esattamente un'istanza.
GetCounters(String)	Recupera un elenco di contatori in una categoria di contatori delle prestazioni che contiene una o più istanze.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetInstanceNames()	Recupera l'elenco di istanze dell'oggetto delle prestazioni associate a questa categoria.
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
InstanceExists(String)	Determina se l'istanza dell'oggetto delle prestazioni specificato è presente nella categoria identificata dalla proprietà PerformanceCounterCategory di questo oggetto CategoryName.
InstanceExists(String, String)	Determina se una categoria specificata sul computer locale contiene l'istanza dell'oggetto delle prestazioni specificato.
InstanceExists(String, String, String)	Determina se una categoria specificata su un particolare computer contiene l'istanza dell'oggetto delle prestazioni specificato.
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ReadCategory()	Legge tutti i dati relativi ai contatori e alle istanze dell'oggetto delle prestazioni associati a questa categoria di contatori delle prestazioni.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Vedi anche

• PerformanceCounter
• CounterCreationDataCollection
• CounterSample