Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

PerformanceCounter (Clase)

Representa un componente de contador de rendimiento de Windows NT.

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

[HostProtectionAttribute(SecurityAction::LinkDemand, Synchronization = true, 
	SharedState = true)]
public ref class PerformanceCounter sealed : public 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 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 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 Component. (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 especificado es igual al objeto actual. (Se hereda de Object).
Método públicoGetHashCode Sirve como una función hash para un tipo en particular. (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 públicoGetType Obtiene el Typede 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 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 Obsoleta. 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.

Hay contadores predefinidos numerosos enumerados en el monitor de rendimiento de Windows Cuadro de diálogo agregar contadores. Para obtener información sobre los contadores de rendimiento de .NET Framework, vea Contadores de rendimiento de .NET Framework.

Este tipo implementa la interfaz IDisposable. Cuando haya terminado de utilizar el tipo, se debe eliminar de directa o indirectamente. Para desechar de tipo directamente, llame al método de Dispose en un bloque de try/decatch . Para desechar de indirectamente, utilice una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para obtener más información, vea “Uso de objeto que implementa sección IDisposable” en el tema de la interfaz de IDisposable .

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.

Además, pasar un objeto de PerformanceCounter al código menos- confirmado puede crear un problema de seguridad. Nunca pase objetos de contador de rendimiento, como PerformanceCounterCategory o PerformanceCounter, a código de menos confianza.

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 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.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;

// Output information about the counter sample.
void OutputSample( CounterSample s )
{
   Console::WriteLine( "\r\n+++++++++++" );
   Console::WriteLine( "Sample values - \r\n" );
   Console::WriteLine( "   BaseValue        = {0}", s.BaseValue );
   Console::WriteLine( "   CounterFrequency = {0}", s.CounterFrequency );
   Console::WriteLine( "   CounterTimeStamp = {0}", s.CounterTimeStamp );
   Console::WriteLine( "   CounterType      = {0}", s.CounterType );
   Console::WriteLine( "   RawValue         = {0}", s.RawValue );
   Console::WriteLine( "   SystemFrequency  = {0}", s.SystemFrequency );
   Console::WriteLine( "   TimeStamp        = {0}", s.TimeStamp );
   Console::WriteLine( "   TimeStamp100nSec = {0}", s.TimeStamp100nSec );
   Console::WriteLine( "++++++++++++++++++++++" );
}

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

bool SetupCategory()
{
   if (  !PerformanceCounterCategory::Exists( "AverageCounter64SampleCategory" ) )
   {
      CounterCreationDataCollection^ CCDC = gcnew CounterCreationDataCollection;

      // Add the counter.
      CounterCreationData^ averageCount64 = gcnew CounterCreationData;
      averageCount64->CounterType = PerformanceCounterType::AverageCount64;
      averageCount64->CounterName = "AverageCounter64Sample";
      CCDC->Add( averageCount64 );

      // Add the base counter.
      CounterCreationData^ averageCount64Base = gcnew 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);
   }
}

void CreateCounters( PerformanceCounter^% PC, PerformanceCounter^% BPC )
{

   // Create the counters.
   PC = gcnew PerformanceCounter( "AverageCounter64SampleCategory","AverageCounter64Sample",false );

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

void CalculateResults( ArrayList^ samplesList )
{
   for ( int i = 0; i < (samplesList->Count - 1); i++ )
   {
      // Output the sample.
      OutputSample(  *safe_cast<CounterSample^>(samplesList[ i ]) );
      OutputSample(  *safe_cast<CounterSample^>(samplesList[ i + 1 ]) );

      // Use .NET to calculate the counter value.
      Console::WriteLine( ".NET computed counter value = {0}", CounterSampleCalculator::ComputeCounterValue(  *safe_cast<CounterSample^>(samplesList[ i ]),  *safe_cast<CounterSample^>(samplesList[ i + 1 ]) ) );

      // Calculate the counter value manually.
      Console::WriteLine( "My computed counter value = {0}", MyComputeCounterValue(  *safe_cast<CounterSample^>(samplesList[ i ]),  *safe_cast<CounterSample^>(samplesList[ i + 1 ]) ) );
   }
}

int main()
{
   ArrayList^ samplesList = gcnew ArrayList;
   PerformanceCounter^ PC;
   PerformanceCounter^ BPC;
   SetupCategory();
   CreateCounters( PC, BPC );
   CollectSamples( samplesList, PC, BPC );
   CalculateResults( samplesList );
}


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.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.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft