Compartir vía


PerformanceCounter.IncrementBy(Int64) Método

Definición

Aumenta o reduce el valor del contador de rendimiento asociado en la cantidad especificada mediante una operación atómica eficaz.

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

Valor que se debe aumentar. (Un valor negativo reduce el contador.)

Devoluciones

Nuevo valor del contador.

Excepciones

El contador es de sólo lectura, por lo que la aplicación no puede aumentarlo.

o bien

La instancia no está correctamente asociada a un contador de rendimiento.

o bien

La propiedad InstanceLifetime se ha establecido en Process pero se está usando la memoria compartida global.

Error de acceso a la API del sistema.

Ejemplos

En el ejemplo de código siguiente se muestra cómo usar el IncrementBy método para agregar incrementos a un contador. Este ejemplo de código forma parte de un ejemplo más grande para la PerformanceCounter clase .

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

Comentarios

Solo puede escribir en contadores personalizados. Todos los contadores del sistema son de solo lectura.

Nota

Los Incrementmétodos , IncrementByy Decrement usan interbloqueos para actualizar el valor del contador. Esto ayuda a mantener el valor de contador preciso en escenarios multiproceso o multiproceso, pero también produce una penalización de rendimiento. Si no necesita la precisión que proporcionan las operaciones interbloqueadas, puede actualizar la RawValue propiedad directamente para una mejora del rendimiento hasta cinco veces. Sin embargo, en escenarios multiproceso, es posible que se omitan algunas actualizaciones del valor del contador, lo que da lugar a datos inexactos.

Nota

Si el valor de la InstanceLifetime propiedad es Process y la categoría de contador de rendimiento se creó con .NET Framework versión 1.0 o 1.1, se produce una InvalidOperationException excepción . Las categorías de contadores de rendimiento creadas con versiones anteriores usan memoria compartida global y el valor de InstanceLifetime debe ser Global. Si las aplicaciones que se ejecutan en las versiones 1.0 o 1.1 de .NET Framework no usan la categoría, elimine y vuelva a crearla.

Se aplica a

Seguridad para subprocesos

Este método es seguro para subprocesos.