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

Clase PerformanceCounter

 

Publicado: octubre de 2016

Representa un componente de contador de rendimiento de Windows NT.

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

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

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

NombreDescripción
System_CAPS_pubmethodPerformanceCounter()

Inicializa una nueva instancia de sólo lectura de la PerformanceCounter (clase), sin asociar la instancia con cualquier contador de rendimiento personalizado o del sistema.

System_CAPS_pubmethodPerformanceCounter(String^, String^)

Inicializa una nueva instancia de sólo lectura de la PerformanceCounter de clase y lo asocia con el contador de rendimiento personalizado en el equipo local o del sistema especificado. Este constructor precisa que la categoría tenga una sola instancia.

System_CAPS_pubmethodPerformanceCounter(String^, String^, Boolean)

Inicializa una nueva de sólo lectura o lectura y escritura instancia de la PerformanceCounter de clase y lo asocia con el contador de rendimiento personalizado en el equipo local o del sistema especificado. Este constructor precisa que la categoría contiene una sola instancia.

System_CAPS_pubmethodPerformanceCounter(String^, String^, String^)

Inicializa una nueva instancia de sólo lectura de la PerformanceCounter de clase y lo asocia con la instancia de categoría y de contador de rendimiento personalizado en el equipo local o del sistema especificado.

System_CAPS_pubmethodPerformanceCounter(String^, String^, String^, Boolean)

Inicializa una nueva de sólo lectura o lectura y escritura instancia de la PerformanceCounter de clase y lo asocia con la instancia de categoría y de contador de rendimiento personalizado en el equipo local o del sistema especificado.

System_CAPS_pubmethodPerformanceCounter(String^, String^, String^, String^)

Inicializa una nueva instancia de sólo lectura de la PerformanceCounter de clase y lo asocia con la instancia de categoría y de contador de rendimiento personalizado, en el equipo especificado o del sistema especificado.

NombreDescripción
System_CAPS_pubpropertyCategoryName

Obtiene o establece el nombre de la categoría de contador de rendimiento para este contador de rendimiento.

System_CAPS_pubpropertyContainer

Obtiene IContainer que contiene Component.(Heredado de Component).

System_CAPS_pubpropertyCounterHelp

Obtiene la descripción para este contador de rendimiento.

System_CAPS_pubpropertyCounterName

Obtiene o establece el nombre del contador de rendimiento asociado a esta PerformanceCounter instancia.

System_CAPS_pubpropertyCounterType

Obtiene el tipo de contador del contador de rendimiento asociado.

System_CAPS_pubpropertyInstanceLifetime

Obtiene o establece la duración de un proceso.

System_CAPS_pubpropertyInstanceName

Obtiene o establece un nombre de instancia para este contador de rendimiento.

System_CAPS_pubpropertyMachineName

Obtiene o establece el nombre de equipo para este contador de rendimiento

System_CAPS_pubpropertyRawValue

Obtiene o establece el valor sin formato o sin calcular de este contador.

System_CAPS_pubpropertyReadOnly

Obtiene o establece un valor que indica si este PerformanceCounter instancia está en modo de sólo lectura.

System_CAPS_pubpropertySite

Obtiene o establece la ISite de la Component.(Heredado de Component).

NombreDescripción
System_CAPS_pubmethodBeginInit()

Comienza la inicialización de un PerformanceCounter instancia utilizada en un formulario o por otro componente. La inicialización se produce en tiempo de ejecución.

System_CAPS_pubmethodClose()

El contador de rendimiento se cierra y libera todos los recursos asignados por esta instancia de contador de rendimiento.

System_CAPS_pubmethodSystem_CAPS_staticCloseSharedResources()

Libera el estado de biblioteca compartida del contador de rendimiento asignado por los contadores.

System_CAPS_pubmethodCreateObjRef(Type^)

Crea un objeto que contiene toda la información pertinente necesaria para generar a un proxy utilizado para comunicarse con un objeto remoto.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodDecrement()

Disminuye el contador de rendimiento asociado en uno, mediante una operación atómica eficaz.

System_CAPS_pubmethodDispose()

Libera todos los recursos que usa Component.(Heredado de Component).

System_CAPS_pubmethodEndInit()

Finaliza la inicialización de un PerformanceCounter instancia que se utiliza en un formulario o por otro componente. La inicialización se produce en tiempo de ejecución.

System_CAPS_pubmethodEquals(Object^)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetLifetimeService()

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodGetType()

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

System_CAPS_pubmethodIncrement()

Incrementa el contador de rendimiento asociado en uno, mediante una operación atómica eficaz.

System_CAPS_pubmethodIncrementBy(Int64)

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

System_CAPS_pubmethodInitializeLifetimeService()

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodNextSample()

Obtiene una muestra de contador y devuelve el valor sin formato o sin calcular para él.

System_CAPS_pubmethodNextValue()

Obtiene una muestra de contador y devuelve el valor calculado para él.

System_CAPS_pubmethodRemoveInstance()

Elimina la instancia de categoría especificada por el PerformanceCounter objeto InstanceName propiedad.

System_CAPS_pubmethodToString()

Devuelve un String que contiene el nombre de la Component, si existe. Este método no se debe invalidar.(Heredado de Component).

NombreDescripción
System_CAPS_pubfieldSystem_CAPS_staticDefaultFileMappingSize

Obsoleto. Especifica el tamaño, en bytes, de la memoria global compartida por los contadores de rendimiento. El tamaño predeterminado es 524.288 bytes.

NombreDescripción
System_CAPS_pubeventDisposed

Se produce cuando el componente se elimina mediante una llamada a la Dispose (método).(Heredado de Component).

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

Hay numerosos contadores predefinidos que se muestran en el Monitor de rendimiento de Windows Add Counters dialog box. Para obtener información acerca de los contadores de rendimiento de .NET Framework, consulte Performance Counters in the .NET Framework.

Este tipo implementa la IDisposable interfaz. Cuando haya terminado de utilizar el tipo, debería eliminar, directa o indirectamente. Para deshacerse del tipo directamente, llame a su Dispose método en un try/catch bloque. Para deshacerse de él indirectamente, usar una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para obtener más información, consulte la sección "Uso de un objeto que implementa IDisposable" en el IDisposable tema de la interfaz.

System_CAPS_importantImportante

En las versiones 1.0 y 1.1 de .NET Framework, esta clase necesita llamadores inmediatos que sean de plena confianza. A partir de la versión 2.0 de .NET Framework, esta clase requiere PerformanceCounterPermission para acciones específicas. Se recomienda encarecidamente que PerformanceCounterPermission no se conceden al código de confianza parcial. La capacidad para leer y escribir contadores de rendimiento permite que el código realizar acciones como enumerar procesos en ejecución y obtener información sobre ellos.

Además, pasando un PerformanceCounter objeto de código de menor confianza puede crear un problema de seguridad. No pasar nunca rendimiento objetos contadores, como un PerformanceCounterCategory o PerformanceCounter, al código de menor confianza.

Para leer de un contador de rendimiento, cree una instancia de la PerformanceCounter clase, establezca el CategoryName, CounterName, y, opcionalmente, el InstanceName o MachineName Propiedades y, a continuación, llame el NextValue método para realizar una lectura del contador de rendimiento.

Para publicar datos del contador de rendimiento, cree uno o más contadores personalizados utilizando el PerformanceCounterCategory::Create método, cree una instancia de la PerformanceCounter clase, establezca el CategoryName, CounterName y, opcionalmente, InstanceName o MachineName Propiedades y, a continuación, llame el IncrementBy, Increment, o Decrement métodos o conjunto el RawValue propiedad para cambiar el valor del contador personalizado.

System_CAPS_noteNota

El Increment, IncrementBy, y Decrement métodos utilizan interbloqueos para actualizar el valor del contador. Esto ayuda a mantener el valor del contador precisos en escenarios multiproceso, pero también produce una reducción del rendimiento. Si no necesita la precisión que entrelazados proporcionar operaciones, puede actualizar el RawValue propiedad directamente de hasta 5 veces la mejora del rendimiento. Sin embargo, en los escenarios multiproceso, algunas actualizaciones para el valor del contador pueden omitirse, produciendo datos inexactos.

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

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

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

En algunos casos, pueden existir varias copias de la misma categoría. Por ejemplo, varios procesos y subprocesos se ejecutan simultáneamente y algunos equipos contienen más de un procesador. Las copias de categoría se denominan instancias de categoría y cada instancia tiene un conjunto de contadores estándares asignados a él. Si una categoría puede tener más de una instancia, una especificación de instancia debe incluirse en la información del contador.

Para obtener datos de rendimiento de los contadores que requieren un valor inicial o anterior para realizar los cálculos necesarios, llame a la NextValue método dos veces y use la información devuelta como requiera la aplicación.

System_CAPS_noteNota

Categorías de contador de rendimiento instaladas con el .NET Framework 2.0 usar memoria compartida independiente, y cada categoría de contador de rendimiento tiene su propia memoria. Puede especificar el tamaño de memoria compartida independiente creando un DWORD denominado FileMappingSize en la clave del registro HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\< nombre de la 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, el fileMappingSize valor del atributo para el performanceCounters se utiliza el elemento especificado en el archivo Machine.config, provocando una sobrecarga adicional para el procesamiento del archivo de configuración. Puede conseguir una mejora del rendimiento de inicio de la aplicación estableciendo el tamaño de asignación del archivo en el registro. Para obtener más información sobre el tamaño de asignación de archivos, consulte <performanceCounters> (Elemento).

Win98WinMe

Performance counters are not supported on Windows 98 or Windows Millennium Edition (Me).

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

#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
Disponible desde 1.1

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: