CounterSample Estructura
TOC
Collapse the table of content
Expand the table of content
Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

CounterSample (Estructura)

 

Define una estructura que contiene los datos sin procesar de un contador de rendimiento.

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

public struct CounterSample

NombreDescripción
System_CAPS_pubmethodCounterSample(Int64, Int64, Int64, Int64, Int64, Int64, PerformanceCounterType)

Inicializa una nueva instancia de la estructura CounterSample y establece el valor de la propiedad CounterTimeStamp en 0 (cero).

System_CAPS_pubmethodCounterSample(Int64, Int64, Int64, Int64, Int64, Int64, PerformanceCounterType, Int64)

Inicializa una nueva instancia de la estructura CounterSample y establece el valor de la propiedad CounterTimeStamp en el valor que se pasa.

NombreDescripción
System_CAPS_pubpropertyBaseValue

Obtiene un valor básico opcional sin formato para el contador.

System_CAPS_pubpropertyCounterFrequency

Obtiene la frecuencia del contador sin formato.

System_CAPS_pubpropertyCounterTimeStamp

Obtiene la marca de hora del contador.

System_CAPS_pubpropertyCounterType

Obtiene el tipo de contador de rendimiento.

System_CAPS_pubpropertyRawValue

Obtiene el valor sin formato del contador.

System_CAPS_pubpropertySystemFrequency

Obtiene la frecuencia del sistema sin formato.

System_CAPS_pubpropertyTimeStamp

Obtiene la marca de hora sin formato.

System_CAPS_pubpropertyTimeStamp100nSec

Obtiene la marca de hora sin formato de alta fidelidad.

NombreDescripción
System_CAPS_pubmethodSystem_CAPS_staticCalculate(CounterSample)

Calcula los datos de rendimiento del contador a partir de un único punto de muestra.Normalmente, este método se utiliza para los tipos de contador de rendimiento sin calcular.

System_CAPS_pubmethodSystem_CAPS_staticCalculate(CounterSample, CounterSample)

Calcula los datos de rendimiento del contador a partir de dos puntos de muestra.Este método suele utilizarse para tipos de contador de rendimiento calculados, como los promedios.

System_CAPS_pubmethodEquals(CounterSample)

Indica si la estructura CounterSample especificada es igual a la estructura CounterSample actual.

System_CAPS_pubmethodEquals(Object)

Indica si la estructura especificada es una estructura CounterSample y si es idéntica a la estructura CounterSample actual.(Reemplaza a ValueType.Equals(Object)).

System_CAPS_pubmethodGetHashCode()

Obtiene un código hash para la actual muestra del contador.(Reemplaza a ValueType.GetHashCode()).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual. (Heredado de Object.)

System_CAPS_pubmethodToString()

Devuelve el nombre de tipo completo de esta instancia.(Heredado de ValueType.)

NombreDescripción
System_CAPS_pubfieldSystem_CAPS_staticEmpty

Define una muestra de contador de rendimiento sin inicializar, vacía, de tipo NumberOfItems32.

NombreDescripción
System_CAPS_puboperatorSystem_CAPS_staticEquality(CounterSample, CounterSample)

Devuelve un valor que indica si dos estructuras CounterSample son iguales.

System_CAPS_puboperatorSystem_CAPS_staticInequality(CounterSample, CounterSample)

Devuelve un valor que indica si dos estructuras CounterSample no son iguales.

El ejemplo siguiente explica el uso de la clase CounterSample para mostrar los datos de un contador de rendimiento.


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

.NET Framework
Disponible desde 1.1

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Volver al principio
Mostrar:
© 2016 Microsoft