PerformanceCounterCategory Classe

Definição

Namespace:

System.Diagnostics

Assembly:

System.Diagnostics.PerformanceCounter.dll

Pacote:

System.Diagnostics.PerformanceCounter v8.0.0

Origem:

PerformanceCounterCategory.cs

Representa um objeto de desempenho, que define uma categoria de contadores de desempenho.

public ref class PerformanceCounterCategory sealed

public sealed class PerformanceCounterCategory

type PerformanceCounterCategory = class

Public NotInheritable Class PerformanceCounterCategory

Herança

Object

PerformanceCounterCategory

Exemplos

O exemplo de código a seguir determina se um PerformanceCounter e seu PerformanceCounterCategory existem no computador local ou em outro computador. Se esses objetos não existirem no computador local, o exemplo os criará opcionalmente. Ele usa o Exists método para determinar se o PerformanceCounterCategory existe. Se o PerformanceCounterCategory não existir e nenhum nome de contador for especificado ou se o computador for um computador remoto, o exemplo será encerrado.

Se um PerformanceCounter nome for fornecido, o exemplo usará o CounterExists método e exibirá o resultado para o usuário. Se o PerformanceCounter não existir, o usuário poderá excluir e recriar o PerformanceCounterCategory com o novo PerformanceCounter. Se o usuário fizer isso, a categoria será excluída usando o Delete método .

Se solicitado, o exemplo agora cria o novo PerformanceCounterCategory e PerformanceCounter usando o Create método . Se um nome de instância for especificado, o exemplo usará o InstanceExists método e exibirá o resultado.

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

Comentários

Importante

Criar ou excluir um contador de desempenho requer a sincronização do código subjacente usando um mutex nomeado. Se um aplicativo altamente privilegiado bloquear o mutex nomeado, tentará criar ou excluir um contador de desempenho fará com que o aplicativo pare de responder até que o bloqueio seja liberado. Para ajudar a evitar esse problema, nunca conceda UnmanagedCode permissão para código não confiável. Além disso, UnmanagedCode a permissão potencialmente permite que outras permissões sejam ignoradas e só devem ser concedidas a código altamente confiável.

A PerformanceCounterCategory propriedade da CategoryName instância é exibida no campo Objeto de Desempenho da caixa de diálogo Adicionar Contador do aplicativo Visualizador de Desempenho.

A PerformanceCounterCategory classe fornece vários métodos para interagir com contadores e categorias no computador. Os Create métodos permitem definir categorias personalizadas. O Delete método fornece uma maneira de remover categorias do computador. O GetCategories método permite exibir a lista de categorias, enquanto ReadCategory recupera todos os dados de contador e instância associados a uma única categoria.

Um contador de desempenho publica dados de desempenho sobre um aplicativo. As categorias incluem componentes físicos (como processadores, discos e memória) e objetos do sistema (como processos e threads). Os contadores do sistema relacionados ao mesmo objeto de desempenho são agrupados em uma categoria que indica seu foco comum. Ao criar uma instância da PerformanceCounter classe, primeiro você indica a categoria com a qual o componente interagirá e, em seguida, escolhe um contador nessa categoria.

Por exemplo, uma categoria de contador do Windows é a categoria Memória. Os contadores do sistema nessa categoria rastreiam dados de memória, como o número de bytes disponíveis e o número de bytes armazenados em cache. Se você quisesse trabalhar com os bytes armazenados em cache em seu aplicativo, criaria uma instância do componente, conectaria-a PerformanceCounter à categoria Memória e, em seguida, escolheria o contador apropriado (nesse caso, Bytes armazenados em cache) nessa categoria.

Embora seu sistema disponibilize muito mais categorias de contador, as categorias com as quais você provavelmente interagirá com mais frequência são as categorias Cache, Memória, Objetos, PhysicalDisk, Processo, Processador, Servidor, Sistema e Thread.

Importante

O RemoveInstance método na PerformanceCounter classe liberará o contador e, se a opção reutilizar for selecionada para essa categoria, a instância do contador será reutilizado. Isso pode causar uma condição de corrida se outro processo ou até mesmo outra parte do código estiver tentando gravar na instância do contador.

Observação

É altamente recomendável que novas categorias de contador de desempenho sejam criadas durante a instalação do aplicativo, não durante a execução do aplicativo. Isso permite tempo para o sistema operacional atualizar sua lista de categorias de contador de desempenho registradas. Se a lista não tiver sido atualizada, a tentativa de usar a categoria falhará.

Observação

As categorias de contador de desempenho instaladas com o .NET Framework 2.0 usam memória compartilhada separada, com cada categoria de contador de desempenho tendo sua própria memória. Você pode especificar o tamanho da memória compartilhada separada criando um DWORD chamado FileMappingSize na chave do Registro HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<nome> da categoria\Desempenho. O valor FileMappingSize é definido como o tamanho da memória compartilhada da categoria. O tamanho padrão é 131072 decimal. Se o valor FileMappingSize não estiver presente, o valor do fileMappingSize atributo para o performanceCounters elemento especificado no arquivo Machine.config será usado, causando sobrecarga adicional para processamento de arquivo de configuração. Você pode perceber uma melhoria de desempenho para a inicialização do aplicativo definindo o tamanho do mapeamento de arquivo no Registro. Para obter mais informações sobre o tamanho do mapeamento de arquivo, consulte <performanceCounters>.

Construtores

PerformanceCounterCategory()	Inicializa uma nova instância da classe PerformanceCounterCategory, deixa a propriedade CategoryName vazia e define a propriedade MachineName para o computador local.
PerformanceCounterCategory(String)	Inicializa uma nova instância da classe PerformanceCounterCategory define a propriedade CategoryName como o valor especificado e define a propriedade MachineName para o computador local.
PerformanceCounterCategory(String, String)	Inicializa uma nova instância da classe PerformanceCounterCategory e define as propriedades CategoryName e MachineName para os valores especificados.

Propriedades

CategoryHelp	Obtém o texto de ajuda da categoria.
CategoryName	Obtém ou define o nome do objeto de desempenho que define essa categoria.
CategoryType	Obtém o tipo de categoria de contador de desempenho.
MachineName	Obtém ou define o nome do computador no qual esta categoria existe.

Métodos

CounterExists(String)	Determina se o contador especificado está registrado para essa categoria, o que é indicado pelas propriedades CategoryName e MachineName.
CounterExists(String, String)	Determina se o contador especificado está registrado para a categoria especificada no computador local.
CounterExists(String, String, String)	Determina se o contador especificado está registrado para a categoria especificada em um computador remoto.
Create(String, String, CounterCreationDataCollection)	Obsoleto. Registra a categoria do contador de desempenho personalizado que contém os contadores especificados no computador local.
Create(String, String, PerformanceCounterCategoryType, CounterCreationDataCollection)	Registra a categoria do contador de desempenho personalizado que contém os contadores especificados no computador local.
Create(String, String, PerformanceCounterCategoryType, String, String)	Registra a categoria do contador de desempenho personalizado que contém um único contador do tipo NumberOfItems32 no computador local.
Create(String, String, String, String)	Obsoleto. Registra uma categoria do contador de desempenho personalizado que contém um único contador do tipo NumberOfItems32 no computador local.
Delete(String)	Remove a categoria e seus contadores associados do computador local.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
Exists(String)	Determina se a categoria está registrada no computador local.
Exists(String, String)	Determina se a categoria está registrada em um computador especificado.
GetCategories()	Recupera uma lista das categorias de contador de desempenho registradas no computador local.
GetCategories(String)	Recupera uma lista das categorias de contador de desempenho que são registradas no computador especificado.
GetCounters()	Recupera uma lista dos contadores em uma categoria de contador de desempenho que contém exatamente uma instância.
GetCounters(String)	Recupera uma lista dos contadores em uma categoria de contador de desempenho que uma ou mais instância.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetInstanceNames()	Recupera a lista de instâncias de objetos de desempenho associados essa categoria.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
InstanceExists(String)	Determina se a instância do objeto de desempenho especificado existe na categoria identificada por este objeto PerformanceCounterCategory, propriedade CategoryName.
InstanceExists(String, String)	Determina se uma categoria especificada no computador local contém a instância do objeto de desempenho especificado.
InstanceExists(String, String, String)	Determina se uma categoria especificada em um computador especificado contém a instância do objeto de desempenho especificado.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
ReadCategory()	Lê todos os contadores e dados de instância do objeto de desempenho associados essa categoria de contador de desempenho.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Confira também

• PerformanceCounter
• CounterCreationDataCollection
• CounterSample