PerformanceCounter.IncrementBy (Método)

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

Espacio de nombres: System.Diagnostics
Ensamblado: System (en system.dll)

public long IncrementBy (
	long value
)
public long IncrementBy (
	long value
)
public function IncrementBy (
	value : long
) : long

Parámetros

value

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

Valor devuelto

Nuevo valor del contador.

Tipo de excepciónCondición

InvalidOperationException

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á utilizando la memoria compartida global.

Win32Exception

Error al obtener acceso a una API del sistema.

PlatformNotSupportedException

La plataforma es Windows 98 o Windows Millennium Edition (Me), que no admiten contadores de rendimiento.

Sólo se puede escribir en los contadores personalizados. Todos los contadores del sistema son de sólo lectura.

NotaNota

Los métodos Increment, IncrementBy y Decrement utilizan interbloqueos para actualizar el valor de contador. Esto ayuda a mantener la precisión del valor de contador en los escenarios multiproceso, pero también produce una reducción del rendimiento. Si no necesita la precisión que proporcionan las operaciones interbloqueadas, puede actualizar la propiedad RawValue directamente y conseguir que el rendimiento mejore hasta 5 veces. Sin embargo, en los escenarios multiproceso, quizás se omitan algunas actualizaciones del valor de contador, produciendo datos inexactos.

NotaNota

Si el valor para la propiedad InstanceLifetime es Process y la categoría de contador de rendimiento se ha creado con la versión 1.0 o 1.1 de .NET Framework, se produce una excepción InvalidOperationException. Las categorías de contador de rendimiento que se crean con las versiones anteriores utilizan la memoria compartida global y el valor de InstanceLifetime debe ser Global. Si las aplicaciones que se ejecutan con las versiones 1.0 o 1.1 de .NET Framework no utilizan la categoría, elimínela y vuelva a crearla.


using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class App {

	private static PerformanceCounter PC;
	private static PerformanceCounter BPC;

	public static void Main()
	{	
	
		ArrayList samplesList = new ArrayList();

		SetupCategory();
		CreateCounters();
		CollectSamples(samplesList);
		CalculateResults(samplesList);

	}
	

	private static bool SetupCategory()
	{		
		if ( !PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") ) 
		{

			CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
			
			// Add the counter.
			CounterCreationData averageCount64 = new CounterCreationData();
			averageCount64.CounterType = PerformanceCounterType.AverageCount64;
			averageCount64.CounterName = "AverageCounter64Sample";
			CCDC.Add(averageCount64);
	        
	        // Add the base counter.
			CounterCreationData averageCount64Base = new 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);
		}
	}
	
	private static void CreateCounters()
	{
		// Create the counters.

		PC = new PerformanceCounter("AverageCounter64SampleCategory", 
			"AverageCounter64Sample", 
			false);
		

		BPC = new PerformanceCounter("AverageCounter64SampleCategory", 
			"AverageCounter64SampleBase", 
			false);
		
		
		PC.RawValue=0;
		BPC.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);

			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 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("++++++++++++++++++++++");
	}
}

import System.*;  
import System.Collections.*;  
import System.Collections.Specialized.*;  
import System.Diagnostics.*;  

public class App
{
    private static PerformanceCounter pc;
    private static PerformanceCounter bpc;

    public static void main(String[] args)
    {
        ArrayList samplesList = new ArrayList();
        SetupCategory();
        CreateCounters();
        CollectSamples(samplesList);
        CalculateResults(samplesList);
    } //main

    private static boolean SetupCategory()
    {
        if (!(PerformanceCounterCategory.Exists(
            "AverageCounter64SampleCategory"))) {
            CounterCreationDataCollection ccdc = 
                new CounterCreationDataCollection();
            // Add the counter.
            CounterCreationData averageCount64 = new CounterCreationData();
            averageCount64.
                set_CounterType(PerformanceCounterType.AverageCount64);
            averageCount64.set_CounterName("AverageCounter64Sample");
            ccdc.Add(averageCount64);
            // Add the base counter.
            CounterCreationData averageCount64Base = new CounterCreationData();
            averageCount64Base.set_CounterType(PerformanceCounterType.
                AverageBase);
            averageCount64Base.set_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;
        }
    } //SetupCategory

    private static void CreateCounters()
    {
        // Create the counters.
        pc = new PerformanceCounter("AverageCounter64SampleCategory",
            "AverageCounter64Sample", false);
        bpc = new PerformanceCounter("AverageCounter64SampleCategory",
            "AverageCounter64SampleBase", false);
        pc.set_RawValue(0);
        bpc.set_RawValue(0);
    } //CreateCounters

    private static void CollectSamples(ArrayList samplesList)
    {
        Random r = new Random(DateTime.get_Now().get_Millisecond());
        // Loop for the samples.
        for (int j = 0; j < 100; j++) {
            int value = r.Next(1, 10);
            Console.Write(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);
        }
    } //CollectSamples

    private static void CalculateResults(ArrayList samplesList)
    {
        for (int i = 0; i < samplesList.get_Count() - 1; i++) {
            // Output the sample.
            OutputSample((CounterSample)samplesList.get_Item(i));
            OutputSample((CounterSample)samplesList.get_Item(i + 1));
            // Use.NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " 
                + CounterSampleCalculator.ComputeCounterValue((CounterSample)
                samplesList.get_Item(i), 
                (CounterSample)samplesList.get_Item(i + 1)));
            // Calculate the counter value manually.
            Console.WriteLine("My computed counter value = "
                + MyComputeCounterValue((CounterSample)samplesList.get_Item(i),
                (CounterSample)samplesList.get_Item(i + 1)));
        }
    } //CalculateResults

    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    //++++++++
    //    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 float MyComputeCounterValue(CounterSample s0,
        CounterSample s1)
    {
        float numerator = (float)s1.get_RawValue() - (float)s0.get_RawValue();
        float denomenator = (float)s1.get_BaseValue() - (float)s0.
            get_BaseValue();
        float counterValue = numerator / denomenator;
        return counterValue;
    } //MyComputeCounterValue

    // 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.get_BaseValue());
        Console.WriteLine("   CounterFrequency = " + s.get_CounterFrequency());
        Console.WriteLine("   CounterTimeStamp = " + s.get_CounterTimeStamp());
        Console.WriteLine("   CounterType      = " + s.get_CounterType());
        Console.WriteLine("   RawValue         = " + s.get_RawValue());
        Console.WriteLine("   SystemFrequency  = " + s.get_SystemFrequency());
        Console.WriteLine("   TimeStamp        = " + s.get_TimeStamp());
        Console.WriteLine("   TimeStamp100nSec = " + s.get_TimeStamp100nSec());
        Console.WriteLine("++++++++++++++++++++++");
    } //OutputSample
} //App

Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0

Adiciones de comunidad

AGREGAR
Mostrar: