PerformanceCounter Classe
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Representa um componente do contador de desempenho do Windows NT.
public ref class PerformanceCounter sealed : System::ComponentModel::Component, System::ComponentModel::ISupportInitializepublic sealed class PerformanceCounter : System.ComponentModel.Component, System.ComponentModel.ISupportInitializetype PerformanceCounter = class
inherit Component
interface ISupportInitializePublic NotInheritable Class PerformanceCounter
Inherits Component
Implements ISupportInitialize- Herança
- Implementações
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.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
// Output information about the counter sample.
void OutputSample( CounterSample s )
{
Console::WriteLine( "\r\n+++++++++++" );
Console::WriteLine( "Sample values - \r\n" );
Console::WriteLine( " BaseValue = {0}", s.BaseValue );
Console::WriteLine( " CounterFrequency = {0}", s.CounterFrequency );
Console::WriteLine( " CounterTimeStamp = {0}", s.CounterTimeStamp );
Console::WriteLine( " CounterType = {0}", s.CounterType );
Console::WriteLine( " RawValue = {0}", s.RawValue );
Console::WriteLine( " SystemFrequency = {0}", s.SystemFrequency );
Console::WriteLine( " TimeStamp = {0}", s.TimeStamp );
Console::WriteLine( " TimeStamp100nSec = {0}", s.TimeStamp100nSec );
Console::WriteLine( "++++++++++++++++++++++" );
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// 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
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
float MyComputeCounterValue( CounterSample s0, CounterSample s1 )
{
float numerator = (float)s1.RawValue - (float)s0.RawValue;
float denomenator = (float)s1.BaseValue - (float)s0.BaseValue;
float counterValue = numerator / denomenator;
return counterValue;
}
bool SetupCategory()
{
if ( !PerformanceCounterCategory::Exists( "AverageCounter64SampleCategory" ) )
{
CounterCreationDataCollection^ CCDC = gcnew CounterCreationDataCollection;
// Add the counter.
CounterCreationData^ averageCount64 = gcnew CounterCreationData;
averageCount64->CounterType = PerformanceCounterType::AverageCount64;
averageCount64->CounterName = "AverageCounter64Sample";
CCDC->Add( averageCount64 );
// Add the base counter.
CounterCreationData^ averageCount64Base = gcnew CounterCreationData;
averageCount64Base->CounterType = PerformanceCounterType::AverageBase;
averageCount64Base->CounterName = "AverageCounter64SampleBase";
CCDC->Add( averageCount64Base );
// Create the category.
PerformanceCounterCategory::Create( "AverageCounter64SampleCategory", "Demonstrates usage of the AverageCounter64 performance counter type.", CCDC );
return (true);
}
else
{
Console::WriteLine( "Category exists - AverageCounter64SampleCategory" );
return (false);
}
}
void CreateCounters( PerformanceCounter^% PC, PerformanceCounter^% BPC )
{
// Create the counters.
PC = gcnew PerformanceCounter( "AverageCounter64SampleCategory","AverageCounter64Sample",false );
BPC = gcnew PerformanceCounter( "AverageCounter64SampleCategory","AverageCounter64SampleBase",false );
PC->RawValue = 0;
BPC->RawValue = 0;
}
void CollectSamples( ArrayList^ samplesList, PerformanceCounter^ PC, PerformanceCounter^ BPC )
{
Random^ r = gcnew Random( DateTime::Now.Millisecond );
// Loop for the samples.
for ( int j = 0; j < 100; j++ )
{
int value = r->Next( 1, 10 );
Console::Write( "{0} = {1}", j, value );
PC->IncrementBy( value );
BPC->Increment();
if ( (j % 10) == 9 )
{
OutputSample( PC->NextSample() );
samplesList->Add( PC->NextSample() );
}
else
Console::WriteLine();
System::Threading::Thread::Sleep( 50 );
}
}
void CalculateResults( ArrayList^ samplesList )
{
for ( int i = 0; i < (samplesList->Count - 1); i++ )
{
// Output the sample.
OutputSample( *safe_cast<CounterSample^>(samplesList[ i ]) );
OutputSample( *safe_cast<CounterSample^>(samplesList[ i + 1 ]) );
// Use .NET to calculate the counter value.
Console::WriteLine( ".NET computed counter value = {0}", CounterSampleCalculator::ComputeCounterValue( *safe_cast<CounterSample^>(samplesList[ i ]), *safe_cast<CounterSample^>(samplesList[ i + 1 ]) ) );
// Calculate the counter value manually.
Console::WriteLine( "My computed counter value = {0}", MyComputeCounterValue( *safe_cast<CounterSample^>(samplesList[ i ]), *safe_cast<CounterSample^>(samplesList[ i + 1 ]) ) );
}
}
int main()
{
ArrayList^ samplesList = gcnew ArrayList;
PerformanceCounter^ PC;
PerformanceCounter^ BPC;
SetupCategory();
CreateCounters( PC, BPC );
CollectSamples( samplesList, PC, BPC );
CalculateResults( samplesList );
}
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 Monitor de Desempenho. Para saber mais sobre os contadores de desempenho do .NET Framework, consulte Contadores de desempenho.
Esse tipo implementa a interface IDisposable. Quando você terminar de usar o tipo, deverá descartá-lo direta ou indiretamente. 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 (em Visual Basic). Saiba mais na seção "Como usar um objeto que implementa IDisposable" no tópico da interface IDisposable.
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íficasPerformanceCounterPermission. É altamente recomendável que PerformanceCounterPermission não seja concedido a 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 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 as CategoryNamepropriedades , CounterNamee, opcionalmente, ou MachineNameInstanceName e 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 as CategoryNamepropriedades e CounterName , opcionalmente, InstanceName ou MachineName e, em seguida, chame os IncrementBymétodos , Incrementou Decrement ou defina a RawValue propriedade para alterar o valor do contador personalizado.
Observação
Os Incrementmétodos , IncrementBye Decrement usam bloqueios 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 interligadas fornecem, atualize a RawValue propriedade diretamente para uma melhoria de desempenho de até 5 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 por meio de 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 estão listados na lista suspensa Objeto de desempenho da caixa de diálogo Adicionar Contadores no 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 requer.
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 o processamento do 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
| PerformanceCounter() |
Inicializa uma nova instância somente leitura da classe PerformanceCounter, sem associar a instância a nenhum sistema ou contador de desempenho personalizado. |
| PerformanceCounter(String, String) |
Inicializa uma instância nova e somente leitura da classe PerformanceCounter e a associa ao contador de desempenho personalizado ou do sistema, especificado no computador local. Este construtor requer que a categoria de tenha uma única instância. |
| PerformanceCounter(String, String, Boolean) |
Inicializa uma instância nova e somente leitura ou de leitura/gravação da classe PerformanceCounter e a associa ao contador de desempenho personalizado ou do sistema especificado no computador local. Este construtor requer que a categoria contenha uma única instância. |
| PerformanceCounter(String, String, String) |
Inicializa uma instância nova e somente leitura da classe PerformanceCounter e a associa ao sistema especificado ou ao contador de desempenho personalizado e à instância de categoria no computador local. |
| PerformanceCounter(String, String, String, Boolean) |
Inicializa uma instância nova e somente leitura ou de leitura/gravação da classe PerformanceCounter e a 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 instância nova e somente leitura da classe PerformanceCounter e a associa ao sistema especificado ou ao contador de desempenho personalizado e à instância de categoria no computador especificado. |
Campos
| DefaultFileMappingSize |
Obsoleto.
Obsoleto.
Obsoleto.
Especifica o tamanho, em bytes, da memória global compartilhada pelos contadores de desempenho. O tamanho padrão é de 524.288 bytes. |
Propriedades
| CanRaiseEvents |
Obtém um valor que indica se o componente pode acionar um evento. (Herdado de Component) |
| CategoryName |
Obtém ou define o nome da categoria do contador de desempenho desse contador de desempenho. |
| Container |
Obtém o IContainer que contém o Component. (Herdado de Component) |
| CounterHelp |
Obtém a descrição para este contador de desempenho. |
| CounterName |
Obtém ou define o nome do contador de desempenho associado a esta instância PerformanceCounter. |
| CounterType |
Obtém o tipo do contador de desempenho associado. |
| DesignMode |
Obtém um valor que indica se o Component está no modo de design no momento. (Herdado de Component) |
| Events |
Obtém a lista de manipuladores de eventos que estão anexados a este Component. (Herdado de Component) |
| InstanceLifetime |
Obtém ou define o tempo de vida de um processo. |
| InstanceName |
Obtém ou define um nome de instância para o contador de desempenho. |
| MachineName |
Obtém ou define um nome do computador para esse 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 esta instância PerformanceCounter está no modo somente leitura. |
| Site |
Obtém ou define o ISite do Component. (Herdado de Component) |
Métodos
| BeginInit() |
Começa a inicialização de uma instância PerformanceCounter 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 esta instância do contador de desempenho. |
| CloseSharedResources() |
Libera o estado compartilhado da biblioteca do contador de desempenho alocado pelos contadores. |
| CreateObjRef(Type) |
Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto. (Herdado de MarshalByRefObject) |
| Decrement() |
Decrementa em um o contador de desempenho associado por meio de uma operação atômica eficiente. |
| Dispose() |
Libera todos os recursos usados pelo Component. (Herdado de Component) |
| Dispose(Boolean) |
Libera os recursos não gerenciados usados pelo Component e opcionalmente libera os recursos gerenciados. (Herdado de Component) |
| EndInit() |
Termina a inicialização de uma instância PerformanceCounter que é usada em um formulário ou por outro componente. A inicialização ocorre em runtime. |
| Equals(Object) |
Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object) |
| GetHashCode() |
Serve como a função de hash padrão. (Herdado de Object) |
| GetLifetimeService() |
Obsoleto.
Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância. (Herdado de MarshalByRefObject) |
| GetService(Type) |
Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container. (Herdado de Component) |
| GetType() |
Obtém o Type da instância atual. (Herdado de Object) |
| Increment() |
Incrementa em um o contador de desempenho associado através de uma operação atômica eficiente. |
| IncrementBy(Int64) |
Incrementa ou diminui o valor do contador de desempenho associado em um valor especificado por meio de uma operação atômica eficiente. |
| InitializeLifetimeService() |
Obsoleto.
Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância. (Herdado de MarshalByRefObject) |
| MemberwiseClone() |
Cria uma cópia superficial do Object atual. (Herdado de Object) |
| MemberwiseClone(Boolean) |
Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject) |
| NextSample() |
Obtém uma amostra de contador e retorna o valor bruto ou não calculado para ela. |
| NextValue() |
Obtém uma amostra de contador e retorna o valor calculado para ela. |
| RemoveInstance() |
Exclui a instância da categoria especificada pelo objeto PerformanceCounter, propriedade InstanceName. |
| ToString() |
Retorna um String que contém o nome do Component, se houver. Esse método não deve ser substituído. (Herdado de Component) |
Eventos
| Disposed |
Ocorre quando o componente é disposto por uma chamada ao método Dispose(). (Herdado de Component) |
