PerformanceCounter Classe

Definição

Namespace:

System.Diagnostics

Assembly:

System.Diagnostics.PerformanceCounter.dll

Origem:

PerformanceCounter.cs

Representa um componente do contador de desempenho do 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

Herança

Object

MarshalByRefObject

Component

PerformanceCounter

Implementações

ISupportInitialize

Exemplos

O exemplo de código a seguir demonstra o uso da PerformanceCounter classe para criar e usar um AverageCount64 tipo de contador. O exemplo cria categorias, configura contadores, coleta dados dos contadores e chama a CounterSampleCalculator classe para interpretar os dados do contador de desempenho. Os resultados intermediários e finais são exibidos na janela do console. Para obter exemplos adicionais de outros tipos de contador de desempenho, consulte a PerformanceCounterType enumeração.

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

Comentários

O PerformanceCounter componente pode ser usado para ler contadores predefinidos ou personalizados existentes e publicar (gravar) dados de desempenho em contadores personalizados.

Há vários contadores predefinidos listados na caixa de diálogo Adicionar Contadores do Windows Performance Monitor. Para saber mais sobre os contadores de desempenho do .NET Framework, consulte Contadores de Desempenho.

Esse tipo implementa a IDisposable interface. Quando terminar de usar esse tipo ou objeto, você deverá descartá-lo de forma direta ou indireta. Para descartar o tipo diretamente, chame o método Dispose dele em um bloco try/catch. Para descartá-lo indiretamente, use um constructo de linguagem como using (em C#) ou Using (no Visual Basic). Para obter mais informações, consulte a seção "Usando um objeto que implementa idisposable" no tópico da IDisposable interface.

Importante

Nas versões 1.0 e 1.1 do .NET Framework, essa classe exige que os chamadores imediatos sejam totalmente confiáveis. A partir do .NET Framework versão 2.0, essa classe requer ações específicas PerformanceCounterPermission . É altamente recomendável que PerformanceCounterPermission não seja concedido ao código semi-confiável. A capacidade de ler e gravar contadores de desempenho permite que o código execute ações como enumerar processos em execução e obter informações sobre eles.

Além disso, passar um PerformanceCounter objeto para um código menos confiável pode criar um problema de segurança. Nunca passe objetos de contador de desempenho, como um PerformanceCounterCategory ou PerformanceCounter, para um código menos confiável.

Para ler de um contador de desempenho, crie uma instância da PerformanceCounter classe, defina o CategoryName, CounterNamee, opcionalmente, as InstanceName propriedades ou MachineName as propriedades e, em seguida, chame o NextValue método para fazer uma leitura de contador de desempenho.

Para publicar dados do contador de desempenho, crie um ou mais contadores personalizados usando o PerformanceCounterCategory.Create método, crie uma instância da PerformanceCounter classe, defina o CategoryName, CounterName e, opcionalmente, InstanceName ou MachineName propriedades, e, em seguida, chame o IncrementBy, Incrementou métodos, ou Decrement defina a RawValue propriedade para alterar o valor do seu contador personalizado.

Observação

Os Incrementmétodos e Decrement os IncrementBymétodos usam intertravamentos para atualizar o valor do contador. Isso ajuda a manter o valor do contador preciso em cenários multithreaded ou multiprocessos, mas também resulta em uma penalidade de desempenho. Se você não precisar da precisão que as operações intertravadas fornecem, você poderá atualizar a RawValue propriedade diretamente para uma melhoria de desempenho de até cinco vezes. No entanto, em cenários multithreaded, algumas atualizações no valor do contador podem ser ignoradas, resultando em dados imprecisos.

O contador é o mecanismo pelo qual os dados de desempenho são coletados. O registro armazena os nomes de todos os contadores, cada um deles relacionado a uma área específica da funcionalidade do sistema. Os exemplos incluem o tempo ocupado de um processador, o uso de memória ou o número de bytes recebidos em uma conexão de rede.

Cada contador é identificado exclusivamente por meio de seu nome e sua localização. Da mesma forma que um caminho de arquivo inclui uma unidade, um diretório, um ou mais subdiretórios e um nome de arquivo, as informações do contador consistem em quatro elementos: o computador, a categoria, a instância de categoria e o nome do contador.

As informações do contador devem incluir a categoria ou o objeto de desempenho para o qual o contador mede os dados. As categorias de um computador incluem componentes físicos, como processadores, discos e memória. Também há categorias de sistema, como processos e threads. Cada categoria está relacionada a um elemento funcional dentro do computador e tem um conjunto de contadores padrão atribuídos a ele. Esses objetos são listados na lista suspensa objeto Performance da caixa de diálogo Adicionar Contadores dentro do Monitor do Sistema do Windows 2000 e você deve incluí-los no caminho do contador. Os dados de desempenho são agrupados pela categoria à qual estão relacionados.

Em determinados casos, podem existir várias cópias da mesma categoria. Por exemplo, vários processos e threads são executados simultaneamente e alguns computadores contêm mais de um processador. As cópias de categoria são chamadas de instâncias de categoria e cada instância tem um conjunto de contadores padrão atribuídos a ela. Se uma categoria puder ter mais de uma instância, uma especificação de instância deverá ser incluída nas informações do contador.

Para obter dados de desempenho para contadores que exigiam um valor inicial ou anterior para executar o cálculo necessário, chame o NextValue método duas vezes e use as informações retornadas conforme o aplicativo exige.

Observação

As categorias de contador de desempenho instaladas com o .NET 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 o processamento de arquivo de configuração. Você pode realizar 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

Nome	Description
PerformanceCounter()	Inicializa uma nova instância somente leitura da PerformanceCounter classe, sem associar a instância a qualquer sistema ou contador de desempenho personalizado.
PerformanceCounter(String, String, Boolean)	Inicializa uma instância nova, somente leitura ou leitura/gravação da classe e a PerformanceCounter associa ao sistema especificado ou ao contador de desempenho personalizado no computador local. Esse construtor requer que a categoria contenha uma única instância.
PerformanceCounter(String, String, String, Boolean)	Inicializa uma instância nova, somente leitura ou leitura/gravação da classe e a PerformanceCounter associa ao sistema especificado ou ao contador de desempenho personalizado e à instância de categoria no computador local.
PerformanceCounter(String, String, String, String)	Inicializa uma nova instância somente leitura da classe e a PerformanceCounter associa ao sistema especificado ou ao contador de desempenho personalizado e à instância de categoria, no computador especificado.
PerformanceCounter(String, String, String)	Inicializa uma nova instância somente leitura da classe e a PerformanceCounter associa ao sistema especificado ou ao contador de desempenho personalizado e à instância de categoria no computador local.
PerformanceCounter(String, String)	Inicializa uma nova instância somente leitura da classe e a PerformanceCounter associa ao sistema especificado ou ao contador de desempenho personalizado no computador local. Esse construtor requer que a categoria tenha uma única instância.

Campos

Nome	Description
DefaultFileMappingSize	Obsoleto. Especifica o tamanho, em bytes, da memória global compartilhada por contadores de desempenho. O tamanho padrão é 524.288 bytes.

Propriedades

Nome	Description
CategoryName	Obtém ou define o nome da categoria do contador de desempenho para esse contador de desempenho.
CounterHelp	Obtém a descrição deste contador de desempenho.
CounterName	Obtém ou define o nome do contador de desempenho associado a essa PerformanceCounter instância.
CounterType	Obtém o tipo de contador do contador de desempenho associado.
InstanceLifetime	Obtém ou define o tempo de vida de um processo.
InstanceName	Obtém ou define um nome de instância para este contador de desempenho.
MachineName	Obtém ou define o nome do computador para este contador de desempenho.
RawValue	Obtém ou define o valor bruto ou não calculado desse contador.
ReadOnly	Obtém ou define um valor que indica se essa PerformanceCounter instância está no modo somente leitura.

Métodos

Nome	Description
BeginInit()	Inicia a inicialização de uma PerformanceCounter instância usada em um formulário ou por outro componente. A inicialização ocorre em runtime.
Close()	Fecha o contador de desempenho e libera todos os recursos alocados por essa instância do contador de desempenho.
CloseSharedResources()	Libera o estado compartilhado da biblioteca de contadores de desempenho alocado pelos contadores.
Decrement()	Diminui o contador de desempenho associado por um por meio de uma operação atômica eficiente.
EndInit()	Termina a inicialização de uma PerformanceCounter instância que é usada em um formulário ou por outro componente. A inicialização ocorre em runtime.
Increment()	Incrementa o contador de desempenho associado por um por meio de uma operação atômica eficiente.
IncrementBy(Int64)	Incrementa ou decrementa o valor do contador de desempenho associado por uma quantidade especificada por meio de uma operação atômica eficiente.
NextSample()	Obtém um exemplo de contador e retorna o valor bruto ou não calculado para ele.
NextValue()	Obtém um exemplo de contador e retorna o valor calculado para ele.
RemoveInstance()	Exclui a instância de categoria especificada pela propriedade do PerformanceCounter objeto InstanceName .

Confira também

• PerformanceCounterType
• CounterCreationData
• CounterCreationDataCollection
• CounterSample
• CounterSampleCalculator