PerformanceCounter.IncrementBy(Int64) Método
Definição
Incrementa ou diminui o valor do contador de desempenho associado em um valor especificado por meio de uma operação atômica eficiente.Increments or decrements the value of the associated performance counter by a specified amount through an efficient atomic operation.
public:
long IncrementBy(long value);
public long IncrementBy (long value);
member this.IncrementBy : int64 -> int64
Public Function IncrementBy (value As Long) As Long
Parâmetros
- value
- Int64
O valor no qual incrementar.The value to increment by. (Um valor negativo diminui o contador.)(A negative value decrements the counter.)
Retornos
O novo valor de contador.The new counter value.
Exceções
O contador é somente leitura para que o aplicativo não possa incrementá-lo.The counter is read-only, so the application cannot increment it.
- ou --or- A instância não está associada corretamente a um contador de desempenho.The instance is not correctly associated with a performance counter.
- ou --or- A propriedade InstanceLifetime está definida como Process ao usar a memória global compartilhada.The InstanceLifetime property is set to Process when using global shared memory.
Ocorreu um erro ao acessar uma API do sistema.An error occurred when accessing a system API.
Exemplos
O exemplo de código a seguir demonstra como usar o IncrementBy método para adicionar incrementos a um contador.The following code example demonstrates how to use the IncrementBy method to add increments to a counter. Este exemplo de código faz parte de um exemplo maior para a PerformanceCounter classe.This code example is part of a larger example for the PerformanceCounter class.
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 );
}
}
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 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
Comentários
Você pode gravar somente em contadores personalizados.You can write only to custom counters. Todos os contadores do sistema são somente leitura.All system counters are read-only.
Observação
Os Increment IncrementBy métodos, e Decrement usam Interlocks para atualizar o valor do contador.The Increment, IncrementBy, and Decrement methods use interlocks to update the counter value. Isso ajuda a manter o valor do contador preciso em cenários multithread ou multiprocesso, mas também resulta em uma penalidade de desempenho.This helps keep the counter value accurate in multithreaded or multiprocess scenarios, but also results in a performance penalty. Se você não precisar da precisão que as operações interligadas fornecem, você pode atualizar a RawValue propriedade diretamente para uma melhoria de desempenho de 5 vezes.If you do not need the accuracy that interlocked operations provide, you can update the RawValue property directly for up to a 5 times performance improvement. No entanto, em cenários multi-threaded, algumas atualizações para o valor do contador podem ser ignoradas, resultando em dados imprecisos.However, in multithreaded scenarios, some updates to the counter value might be ignored, resulting in inaccurate data.
Observação
Se o valor da InstanceLifetime propriedade for Process e a categoria do contador de desempenho tiver sido criada com .NET Framework versão 1,0 ou 1,1, um InvalidOperationException será lançado.If the value for the InstanceLifetime property is Process and the performance counter category was created with .NET Framework version 1.0 or 1.1, an InvalidOperationException is thrown. As categorias de contador de desempenho criadas com versões anteriores usam a memória compartilhada global e o valor de InstanceLifetime deve ser Global .Performance counter categories created with earlier versions use global shared memory, and the value for InstanceLifetime must be Global. Se a categoria não for usada por aplicativos em execução nas versões 1,0 ou 1,1 do .NET Framework, exclua e recrie a categoria.If the category is not used by applications running on versions 1.0 or 1.1 of the .NET Framework, delete and recreate the category.
Aplica-se a
Acesso thread-safe
Este método é thread-safe.This method is thread safe.