Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original.
Traducción
Original

PerformanceCounter (Clase)

Representa un componente de contador de rendimiento de Windows NT.

System.Object
  System.MarshalByRefObject
    System.ComponentModel.Component
      System.Diagnostics.PerformanceCounter

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

[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	SharedState = true)]
public sealed class PerformanceCounter : Component, 
	ISupportInitialize

El tipo PerformanceCounter expone los siguientes miembros.

  NombreDescripción
Método públicoPerformanceCounter()Inicializa una nueva instancia de sólo lectura de la clase PerformanceCounter, sin asociar la instancia a ningún contador de rendimiento del sistema o personalizado.
Método públicoPerformanceCounter(String, String)Inicializa una nueva instancia de sólo lectura de la clase PerformanceCounter y la asocia al contador de rendimiento personalizado o del sistema especificado en el equipo local. Este constructor precisa que la categoría tenga una sola instancia.
Método públicoPerformanceCounter(String, String, Boolean)Inicializa una nueva instancia de sólo lectura o de lectura y escritura de la clase PerformanceCounter y la asocia al contador de rendimiento personalizado o del sistema especificado en el equipo local. Este constructor precisa que la categoría contenga una sola instancia.
Método públicoPerformanceCounter(String, String, String)Inicializa una nueva instancia de sólo lectura de la clase PerformanceCounter y la asocia al contador de rendimiento personalizado o del sistema y a la instancia de categoría especificados en el equipo local.
Método públicoPerformanceCounter(String, String, String, Boolean)Inicializa una nueva instancia de sólo lectura o de lectura y escritura de la clase PerformanceCounter y la asocia al contador de rendimiento personalizado o del sistema y a la instancia de categoría especificados en el equipo local.
Método públicoPerformanceCounter(String, String, String, String)Inicializa una nueva instancia de sólo lectura de la clase PerformanceCounter y la asocia al contador de rendimiento personalizado o del sistema y a la instancia de categoría indicados en el equipo especificado.
Arriba

  NombreDescripción
Propiedad protegidaCanRaiseEventsObtiene un valor que indica si el componente puede generar un evento. (Se hereda de Component).
Propiedad públicaCategoryNameObtiene o establece el nombre de la categoría de contador de rendimiento para este contador de rendimiento.
Propiedad públicaContainerObtiene IContainer que contiene Component. (Se hereda de Component).
Propiedad públicaCounterHelpObtiene la descripción de este contador de rendimiento.
Propiedad públicaCounterNameObtiene o establece el nombre del contador de rendimiento asociado a esta instancia de PerformanceCounter.
Propiedad públicaCounterTypeObtiene el tipo de contador del contador de rendimiento asociado.
Propiedad protegidaDesignModeObtiene un valor que indica si Component está actualmente en modo de diseño. (Se hereda de Component).
Propiedad protegidaEventsObtiene la lista de controladores de eventos asociados a Component. (Se hereda de Component).
Propiedad públicaInstanceLifetimeObtiene o establece el período de duración de un proceso.
Propiedad públicaInstanceNameObtiene o establece un nombre de instancia para este contador de rendimiento.
Propiedad públicaMachineNameObtiene o establece el nombre de equipo para este contador de rendimiento
Propiedad públicaRawValueObtiene o establece el valor sin formato o sin calcular de este contador.
Propiedad públicaReadOnlyObtiene o establece un valor que indica si esta instancia de PerformanceCounter está en modo de sólo lectura.
Propiedad públicaSiteObtiene o establece ISite de Component. (Se hereda de Component).
Arriba

  NombreDescripción
Método públicoBeginInitActiva la inicialización de una instancia de PerformanceCounter que se utiliza en un formulario o que otro componente utiliza. La inicialización se produce en tiempo de ejecución.
Método públicoCloseCierra el contador de rendimiento y libera todos los recursos asignados por esta instancia de contador de rendimiento.
Método públicoMiembro estáticoCloseSharedResourcesLibera el estado compartido de la biblioteca de contadores de rendimiento asignado por los contadores.
Método públicoCreateObjRefCrea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Se hereda de MarshalByRefObject).
Método públicoDecrementReduce el valor del contador de rendimiento asociado en uno, mediante una operación atómica eficaz.
Método públicoDispose()Libera todos los recursos utilizados por el objeto Component. (Se hereda de Component).
Método protegidoDispose(Boolean)Libera los recursos no administrados usados por Component y, opcionalmente, los recursos administrados. (Se hereda de Component).
Método públicoEndInitFinaliza la inicialización de una instancia de PerformanceCounter que se utiliza en un formulario o en otro componente. La inicialización se produce en tiempo de ejecución.
Método públicoEquals(Object)Determina si el objeto Object especificado es igual al objeto Object actual. (Se hereda de Object).
Método protegidoFinalizeLibera recursos no administrados y realiza otras operaciones de limpieza antes de que se reclame el objeto Component durante la recolección de elementos no utilizados. (Se hereda de Component).
Método públicoGetHashCodeActúa como función hash para un tipo concreto. (Se hereda de Object).
Método públicoGetLifetimeServiceRecupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Se hereda de MarshalByRefObject).
Método protegidoGetServiceDevuelve un objeto que representa el servicio suministrado por Component o por Container. (Se hereda de Component).
Método públicoGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoIncrementAumenta el valor del contador de rendimiento asociado en uno, mediante una operación atómica eficaz.
Método públicoIncrementByAumenta o reduce el valor del contador de rendimiento asociado en la cantidad especificada mediante una operación atómica eficaz.
Método públicoInitializeLifetimeServiceObtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Se hereda de MarshalByRefObject).
Método protegidoMemberwiseClone() Crea una copia superficial del Object actual. (Se hereda de Object).
Método protegidoMemberwiseClone(Boolean)Crea una copia superficial del objeto MarshalByRefObject actual. (Se hereda de MarshalByRefObject).
Método públicoNextSampleObtiene un contador de ejemplo y devuelve su valor sin formato o sin calcular.
Método públicoNextValueObtiene un contador de ejemplo y devuelve su valor calculado.
Método públicoRemoveInstanceElimina la instancia de categoría especificada por la propiedad InstanceName del objeto PerformanceCounter.
Método públicoToStringDevuelve un objeto String que contiene el nombre del objeto Component, en caso de que exista. Este método no debe reemplazarse. (Se hereda de Component).
Arriba

  NombreDescripción
Evento públicoDisposedSe produce cuando el componente se elimina mediante una llamada al método Dispose. (Se hereda de Component).
Arriba

  NombreDescripción
Campo públicoMiembro estáticoDefaultFileMappingSize Obsoleto. Especifica el tamaño (en bytes) de la memoria global compartida por los contadores de rendimiento. El tamaño predeterminado es de 524.288 bytes.
Arriba

El componente PerformanceCounter se puede utilizar para leer contadores personalizados o contadores predefinidos existentes, y para publicar (escribir) datos de rendimiento en contadores personalizados.

Nota importanteImportante

   En las versiones 1.0 y 1.1 de .NET Framework, esta clase necesita llamadores inmediatos que sean de plena confianza. Al iniciar con la versión 2.0 de .NET Framework, esta clase requiere PerformanceCounterPermission para acciones concretas. Se recomienda encarecidamente que PerformanceCounterPermission no se conceda a código que no sea de plena confianza. La capacidad de leer y escribir contadores de rendimiento permite que el código realice acciones como enumerar procesos en ejecución y obtener información sobre ellos.

Nota de precauciónPrecaución

Si se pasa un objeto PerformanceCounter a código de menos confianza puede crear un problema de seguridad. Nunca pase objetos de contador de rendimiento, como PerformanceCounterCategory o PerformanceCounter, a código de menos confianza.

Los contadores predefinidos son demasiado numerosos para mencionar y son específicos del producto. Para obtener información sobre los contadores de rendimiento de .NET Framework, vea Contadores de rendimiento de .NET Framework.

Para leer de un contador de rendimiento, hay que crear una instancia de la clase PerformanceCounter, establecer las propiedades CategoryName, CounterName y, opcionalmente, InstanceName o MachineName, y después llamar al método NextValue para obtener una lectura del contador de rendimiento.

Para publicar datos del contador de rendimiento, hay que crear uno o más contadores personalizados utilizando el método PerformanceCounterCategory.Create, crear una instancia de la clase PerformanceCounter, establecer las propiedades CategoryName, CounterName y, opcionalmente, InstanceName o MachineName, y después llamar a los métodos IncrementBy, Increment o Decrement, o establecer la propiedad RawValue para cambiar el valor del contador personalizado.

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.

El contador es el mecanismo mediante el cual se recopilan datos de rendimiento. El Registro almacena los nombres de todos los contadores, cada uno de los cuales está relacionado con un área de funcionalidad específica del sistema. Entre otros ejemplos, se incluyen el tiempo de ocupación de un procesador, el uso de memoria o el número de bytes recibidos a través de una conexión de red.

Cada contador se identifica de forma inequívoca mediante su nombre y su ubicación. Del mismo modo que una ruta de acceso a un archivo incluye una unidad, un directorio, uno o más subdirectorios y un nombre de archivo, la información del contador se compone de cuatro elementos: el equipo, la categoría, la instancia de la categoría y el nombre del contador.

La información del contador debe incluir la categoría, o el objeto de rendimiento, cuyos datos mide el contador. Las categorías de un equipo incluyen los componentes físicos, como los procesadores, los discos y la memoria. También hay categorías del sistema, como procesos y subprocesos. Cada categoría está relacionada con un elemento funcional del equipo y tiene asignado un conjunto de contadores estándar. Estos objetos se enumeran en la lista desplegable Objeto de rendimiento del cuadro de diálogo Agregar contadores del Monitor de sistema de Windows 2000 y debe incluirlos en la ruta de acceso del contador. Los datos de rendimiento se agrupan por categorías, en función de la categoría con la que estén relacionados.

En algunos casos, pueden existir varias copias de la misma categoría. Esto se debe, por ejemplo, a que varios procesos y subprocesos se ejecutan simultáneamente y a que algunos equipos contienen más de un procesador. Las copias de categoría se denominan instancias de categoría. Cada instancia tiene asignado un conjunto de contadores estándar. Si una categoría puede contener más de una instancia, es necesario incluir una especificación de instancia en la información del contador.

Para obtener los datos de rendimiento de los contadores que requieren un valor inicial o un valor anterior para realizar los cálculos necesarios, llame al método NextValue dos veces y utilice la información que devuelve en función de las necesidades de la aplicación.

NotaNota

Las categorías de contador de rendimiento instaladas con .NET Framework 2.0 utilizan memoria compartida independiente, y cada categoría de contador de rendimiento tiene su propia memoria. Se puede especificar el tamaño de la memoria compartida independiente creando un DWORD denominado FileMappingSize en la clave del Registro HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<nombre de categoría>\Performance. El valor de FileMappingSize se establece en el tamaño de memoria compartida de la categoría. El tamaño predeterminado es el valor decimal 131072. Si el valor de FileMappingSize no está presente, se utiliza el valor del atributo fileMappingSize para el elemento performanceCounters especificado en el archivo Machine.config, lo que provoca una sobrecarga adicional en el procesamiento del archivo de configuración. Puede apreciar una mejora del rendimiento en el inicio de la aplicación estableciendo el tamaño de asignación de archivos en el Registro. Para obtener más información sobre el tamaño de asignación de archivos, vea <performanceCounters> (Elemento).

NotaNota

El atributo HostProtectionAttribute aplicado a este tipo o miembro tiene el siguiente valor de la propiedad Resources: Synchronization | SharedState. El atributo HostProtectionAttribute no afecta a las aplicaciones de escritorio (que normalmente se inician haciendo doble clic en un icono, escribiendo un comando o introduciendo una dirección URL en el explorador). Para obtener más información, vea la clase HostProtectionAttribute o Programación en SQL Server y atributos de protección de host.

Nota de la plataforma : Los contadores de rendimiento no son compatibles con Windows 98 y Windows Millennium Edition (Me).

En el siguiente ejemplo de código se muestra el uso de la clase PerformanceCounter para crear y usar un tipo de contador AverageCount64. El ejemplo crea las categorías, configura los contadores, recopila los datos de los contadores y llama a la clase CounterSampleCalculator para interpretar los datos del contador de rendimiento. Los resultados intermedio y final se muestran en la ventana de la consola. Para obtener ejemplos adicionales de otros tipos de contador de rendimiento, vea la enumeración PerformanceCounterType.



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();

        // 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 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.",
                PerformanceCounterCategoryType.SingleInstance, 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("++++++++++++++++++++++");
	}
}


.NET Framework

Compatible con: 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos 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.

date

Historial

Motivo

Septiembre de 2010

Corregida la información de seguridad para subprocesos; el tipo no es seguro para subprocesos.

Corrección de errores de contenido.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft