PerformanceCounterType (Enumeración)

 

Especifica la fórmula que se utiliza para calcular el método NextValue para una instancia de PerformanceCounter.

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

public enum class PerformanceCounterType

Nombre de miembroDescripción
AverageBase

Contador base que se utiliza para calcular el promedio de tiempos o recuentos, como AverageTimer32 y AverageCount64.Almacena el denominador que se utiliza en el cálculo de un contador para presentar el "tiempo por operación" o el "recuento por operación".

AverageCount64

Contador de promedio que muestra cuántos elementos se procesan de promedio durante una operación.Los contadores de este tipo muestran la relación entre los elementos procesados y el número de operaciones completadas.Dicha relación se calcula comparando el número de elementos procesados durante el último intervalo con el número de operaciones completadas durante el mismo intervalo.

AverageTimer32

Contador de tipo promedio que mide el tiempo transcurrido, de promedio, para completar un proceso u operación.Los contadores de este tipo muestran la relación entre el tiempo total transcurrido del intervalo de muestra y el número de procesos u operaciones completadas durante dicho tiempo.Este tipo de contador mide el tiempo en pasos del reloj del sistema.

CounterDelta32

Contador de diferencia que muestra la variación del atributo medido entre los dos intervalos de muestra más recientes.

CounterDelta64

Contador de diferencia que muestra la variación del atributo medido entre los dos intervalos de muestra más recientes.Es lo mismo que el tipo de contador CounterDelta32, salvo que utiliza campos de mayor tamaño para poder albergar valores más grandes.

CounterMultiBase

Contador base que indica el número de elementos analizados en la muestra.Se utiliza como denominador en los cálculos, para obtener un promedio de los elementos muestreados al tomar mediciones de tiempo de varios elementos similares.Se utiliza con CounterMultiTimer, CounterMultiTimerInverse, CounterMultiTimer100Ns y CounterMultiTimer100NsInverse.

CounterMultiTimer

Contador de porcentaje que muestra el tiempo activo de uno o más componentes como un porcentaje del tiempo total del intervalo de muestra.Debido a que el numerador registra el tiempo activo de componentes que funcionan simultáneamente, el porcentaje resultante puede superar el 100 por ciento.

CounterMultiTimer100Ns

Contador de porcentaje que muestra el tiempo activo de uno o más componentes como un porcentaje del tiempo total del intervalo de muestra.Mide el tiempo en unidades de 100 nanosegundos (ns).

CounterMultiTimer100NsInverse

Contador de porcentaje que muestra el tiempo activo de uno o más componentes como un porcentaje del tiempo total del intervalo de muestra.Los contadores de este tipo miden el tiempo en unidades de 100 nanosegundos (ns).Derivan el tiempo activo midiendo el tiempo durante el cual los componentes no estaban activos y restándole el resultado de multiplicar 100 por ciento por el número de objetos supervisados.

CounterMultiTimerInverse

Contador de porcentaje que muestra el tiempo activo de uno o más componentes como un porcentaje del tiempo total del intervalo de muestra.Deriva el tiempo activo midiendo el tiempo durante el cual los componentes no estaban activos y restándole el resultado de multiplicar 100 por ciento por el número de objetos supervisados.

CounterTimer

Contador de porcentaje que muestra el promedio de tiempo que un componente está activo como un porcentaje del tiempo de muestra total.

CounterTimerInverse

Contador de porcentaje que muestra el porcentaje promedio de tiempo activo observado durante el intervalo de muestra.El valor de estos contadores se calcula supervisando el porcentaje de tiempo que el servicio estuvo inactivo y restando ese valor del 100 por ciento.

CountPerTimeInterval32

Contador de promedio diseñado para supervisar la longitud promedio de la cola de un recurso a lo largo de un determinado período de tiempo.Muestra la diferencia entre las longitudes de cola observadas durante los dos últimos intervalos de muestra, dividida por la duración del intervalo.Este tipo de contador se utiliza normalmente para hacer un seguimiento del número de elementos que están en la cola o a la espera.

CountPerTimeInterval64

Contador de promedio que supervisa la longitud promedio de la cola de un recurso a lo largo de un determinado período de tiempo.Los contadores de este tipo muestran la diferencia entre las longitudes de cola observadas durante los dos últimos intervalos de muestra, dividida por la duración del intervalo.Este tipo de contador es lo mismo que CountPerTimeInterval32, salvo que utiliza campos de mayor tamaño para poder albergar valores más grandes.Este tipo de contador se utiliza normalmente para hacer un seguimiento de un gran volumen o de un número muy elevado de elementos que están en la cola o a la espera.

ElapsedTime

Temporizador de diferencia que muestra el tiempo total transcurrido entre el inicio de un componente o proceso y el momento en que se calcula este valor.

NumberOfItems32

Contador instantáneo que muestra el valor observado más reciente.Se utiliza, por ejemplo, para mantener un recuento simple de elementos o de operaciones.

NumberOfItems64

Contador instantáneo que muestra el valor observado más reciente.Se utiliza, por ejemplo, para mantener un recuento simple de un número muy elevado de elementos o de operaciones.Este tipo de contador es lo mismo que NumberOfItems32, salvo que utiliza campos de mayor tamaño para poder albergar valores más grandes.

NumberOfItemsHEX32

Contador instantáneo que muestra el valor observado más reciente en formato hexadecimal.Se utiliza, por ejemplo, para mantener un recuento simple de elementos o de operaciones.

NumberOfItemsHEX64

Contador instantáneo que muestra el valor observado más reciente.Se utiliza, por ejemplo, para mantener un recuento simple de un número muy elevado de elementos o de operaciones.Este tipo de contador es lo mismo que NumberOfItemsHEX32, salvo que utiliza campos de mayor tamaño para poder albergar valores más grandes.

RateOfCountsPerSecond32

Contador de diferencia que muestra el número promedio de operaciones completadas durante cada segundo del intervalo de muestra.Este tipo de contador mide el tiempo en pasos del reloj del sistema.

RateOfCountsPerSecond64

Contador de diferencia que muestra el número promedio de operaciones completadas durante cada segundo del intervalo de muestra.Este tipo de contador mide el tiempo en pasos del reloj del sistema.Este tipo de contador es el mismo que el tipo RateOfCountsPerSecond32, pero utiliza campos más grandes para albergar valores más grandes y así supervisar un alto número de elementos u operaciones por segundo, como por ejemplo una tasa de transmisión de bytes.

RawBase

Contador base que almacena el denominador de un contador que presenta una fracción aritmética general.Compruebe que este valor es mayor que cero antes de utilizarlo como denominador para calcular el valor RawFraction.

RawFraction

Contador de porcentaje instantáneo que muestra la relación entre un subconjunto y su conjunto, en porcentaje.Por ejemplo, compara el número de bytes utilizados en un disco con el número total de bytes que contiene el disco.Los contadores de este tipo muestran sólo el porcentaje actual, no un promedio a lo largo del tiempo.

SampleBase

Contador base que almacena el número de interrupciones de muestreo tomadas y se utiliza como denominador en la fracción de muestreo.La fracción de muestreo es el número de muestras que dieron 1 (o true) para una interrupción de muestra.Compruebe que este valor es mayor que cero antes de utilizarlo como denominador para calcular SampleFraction.

SampleCounter

Contador de promedio que muestra el promedio de operaciones completadas en un segundo.Cuando un contador de este tipo toma una muestra de los datos, cada interrupción de muestreo devuelve uno o cero.Los datos del contador son el número de contadores muestreados.Mide el tiempo en unidades de pasos del temporizador de rendimiento del sistema.

SampleFraction

Contador de porcentaje que muestra la relación media entre el número de aciertos y todas las operaciones realizadas durante los dos últimos intervalos de muestra.

Timer100Ns

Contador de porcentaje que muestra el tiempo activo de un componente como un porcentaje del tiempo total transcurrido del intervalo de muestra.Mide el tiempo en unidades de 100 nanosegundos (ns).Los contadores de este tipo están diseñados para medir la actividad de un componente en cada momento.

Timer100NsInverse

Contador de porcentaje que muestra el porcentaje promedio de tiempo activo observado durante el intervalo de muestra.

Algunos tipos de contador representan datos sin procesar, mientras que otros representan valores calculados que se basan en una o más muestras de contador.Las categorías siguientes clasifican los tipos de contadores disponibles.

  • Average (Promedio): mide un valor a lo largo de un período y muestra el promedio entre las dos últimas mediciones.Se asocia a cada contador de promedio un contador base que registra el número de muestras utilizadas.

  • Difference (Diferencia): resta la última medición de la anterior y muestra la diferencia si es positiva; si es negativa, muestra un cero.

  • Instantaneous (Instantánea): muestra la medición más reciente.

  • Percentage (Porcentaje): muestra los valores calculados como un porcentaje.

  • Rate (Tasa): efectúa una muestra de un número de eventos en aumento a lo largo de un período y divide la variación del número de eventos por la variación en tiempo, lo cual refleja una tasa de actividad.

Al realizar muestreos de datos de contadores de rendimiento, utilizar un tipo de contador que represente un promedio puede hacer que los valores de datos sin procesar resulten de utilidad.Por ejemplo, el contador de datos sin procesar NumberOfItems64 puede exponer datos que sean muy aleatorios entre una muestra y otra.La fórmula para calcular el promedio de valores que el contador devuelve sería (X 0 +X 1 +…+X n)/n, donde cada X i representa una muestra de contador sin formato.

Los contadores de tasa son similares a los contadores de promedio, pero son más útiles en situaciones donde la tasa aumenta a medida que se utiliza un recurso. Una fórmula que calcula rápidamente el promedio es ((X n -X 0)/(T n -T 0)) / frecuencia, donde cada X i es una muestra de contador y cada T i es el tiempo que se tomó la correspondiente muestra.El resultado es el promedio de uso por segundo.

System_CAPS_noteNota

A menos que se indique lo contrario, la base de tiempo se expresa en segundos.

Al instrumentar aplicaciones (crear y escribir contadores de rendimiento personalizados), es posible trabajar con tipos de contador basados en un contador base complementario que se utilice en los cálculos.El contador base debe encontrarse inmediatamente después del contador asociado en la colección CounterCreationDataCollection que utiliza la aplicación.En la siguiente tabla se muestran los tipos de contador base con los tipos de contador de rendimiento correspondientes.

Tipo de contador base

Tipos de contador de rendimiento

AverageBase

AverageTimer32

AverageCount64

CounterMultiBase

CounterMultiTimer

CounterMultiTimerInverse

CounterMultiTimer100Ns

CounterMultiTimer100NsInverse

RawBase

RawFraction

SampleBase

SampleFraction

En los ejemplos siguientes se muestran algunos de los tipos de contador de la enumeración PerformanceCounterType.

AverageCount64

#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 );
}

AverageTimer32

#using <System.dll>

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

//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
// PERF_AVERAGE_TIMER
//  Description - This counter type measures the time it takes, on 
//     average, to complete a process or operation. Counters of this
//     type display a ratio of the total elapsed time of the sample 
//     interval to the number of processes or operations completed
//     during that time. This counter type measures time in ticks 
//     of the system clock. The F variable represents the number of
//     ticks per second. The value of F is factored into the equation
//     so that the result can be displayed in seconds.
//    
//  Generic type - Average
//    
//  Formula - ((N1 - N0) / F) / (D1 - D0), where the numerator (N)
//     represents the number of ticks counted during the last 
//     sample interval, F represents the frequency of the ticks, 
//     and the denominator (D) represents the number of operations
//     completed during the last sample interval.
//    
//  Average - ((Nx - N0) / F) / (Dx - D0)
//    
//  Example - PhysicalDisk\ Avg. Disk sec/Transfer 
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
float MyComputeCounterValue( CounterSample s0, CounterSample s1 )
{
    __int64 n1 = s1.RawValue;
    __int64 n0 = s0.RawValue;
    unsigned __int64 f = s1.SystemFrequency;
    __int64 d1 = s1.BaseValue;
    __int64 d0 = s0.BaseValue;
    double numerator = (double)(n1 - n0);
    double denominator = (double)(d1 - d0);
    float counterValue = (float)((numerator / f) / denominator);
    return counterValue;
}

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

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

        // Add the counter.
        CounterCreationData^ averageTimer32 = gcnew CounterCreationData;
        averageTimer32->CounterType = PerformanceCounterType::AverageTimer32;
        averageTimer32->CounterName = "AverageTimer32Sample";
        CCDC->Add( averageTimer32 );

        // Add the base counter.
        CounterCreationData^ averageTimer32Base = gcnew CounterCreationData;
        averageTimer32Base->CounterType = PerformanceCounterType::AverageBase;
        averageTimer32Base->CounterName = "AverageTimer32SampleBase";
        CCDC->Add( averageTimer32Base );

        // Create the category.
        PerformanceCounterCategory::Create( "AverageTimer32SampleCategory", 
            "Demonstrates usage of the AverageTimer32 performance counter type", 
            PerformanceCounterCategoryType::SingleInstance, CCDC );
        Console::WriteLine( "Category created - AverageTimer32SampleCategory" );
        return (true);
        }

    Console::WriteLine( "Category exists - AverageTimer32SampleCategory" );
    return (false);
}

void CreateCounters( PerformanceCounter^% PC, PerformanceCounter^% BPC )
{
    // Create the counters.
    PC = gcnew PerformanceCounter( "AverageTimer32SampleCategory","AverageTimer32Sample",false );
    BPC = gcnew PerformanceCounter( "AverageTimer32SampleCategory","AverageTimer32SampleBase",false );
    PC->RawValue = 0;
    BPC->RawValue = 0;
}

void CollectSamples( ArrayList^ samplesList, PerformanceCounter^ PC, 
PerformanceCounter^ BPC )
{
    __int64 perfTime = 0;
    Random^ r = gcnew Random( DateTime::Now.Millisecond );

    // Loop for the samples.
    for ( int i = 0; i < 10; i++ )
        {
        PC->RawValue = Stopwatch::GetTimestamp();
        BPC->IncrementBy( 10 );
        System::Threading::Thread::Sleep( 1000 );
        Console::WriteLine( "Next value = {0}", PC->NextValue().ToString() );
        samplesList->Add( PC->NextSample() );
        }
}

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}",
           CounterSample::Calculate(  *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 );

    Console::WriteLine("\n\nHit ENTER to return");
    Console::ReadLine();
}

ElapsedTime

#using <System.dll>

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

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

void CollectSamples()
{
   String^ categoryName = "ElapsedTimeSampleCategory";
   String^ counterName = "ElapsedTimeSample";

   // Create the performance counter category.
   if (  !PerformanceCounterCategory::Exists( categoryName ) )
   {
      CounterCreationDataCollection^ CCDC = gcnew CounterCreationDataCollection;

      // Add the counter.
      CounterCreationData^ ETimeData = gcnew CounterCreationData;
      ETimeData->CounterType = PerformanceCounterType::ElapsedTime;
      ETimeData->CounterName = counterName;
      CCDC->Add( ETimeData );

      // Create the category.
      PerformanceCounterCategory::Create( categoryName,
         "Demonstrates ElapsedTime performance counter usage.",
         CCDC );
   }
   else
   {
      Console::WriteLine( "Category exists - {0}", categoryName );
   }


   // Create the performance counter.
   PerformanceCounter^ PC = gcnew PerformanceCounter( categoryName,
                                                      counterName,
                                                      false );
   // Initialize the counter.
   PC->RawValue = Stopwatch::GetTimestamp();

   DateTime Start = DateTime::Now;

   // Loop for the samples.
   for ( int j = 0; j < 100; j++ )
   {
      // Output the values.
      if ( (j % 10) == 9 )
      {
         Console::WriteLine( "NextValue() = {0}", PC->NextValue() );
         Console::WriteLine( "Actual elapsed time = {0}", DateTime::Now.Subtract( Start ) );
         OutputSample( PC->NextSample() );
      }

      // Reset the counter on every 20th iteration.
      if ( j % 20 == 0 )
      {
         PC->RawValue = Stopwatch::GetTimestamp();
         Start = DateTime::Now;
      }
      System::Threading::Thread::Sleep( 50 );
   }

   Console::WriteLine( "Elapsed time = {0}", DateTime::Now.Subtract( Start ) );
}

int main()
{
   CollectSamples();
}

NumberOfItems32

#using <System.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
float MyComputeCounterValue( CounterSample s0, CounterSample s1 )
{
   float counterValue = (float)s1.RawValue;
   return counterValue;
}

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

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

      // Add the counter.
      CounterCreationData^ NOI64 = gcnew CounterCreationData;
      NOI64->CounterType = PerformanceCounterType::NumberOfItems64;
      NOI64->CounterName = "NumberOfItems32Sample";
      CCDC->Add( NOI64 );

      // Create the category.
      PerformanceCounterCategory::Create( "NumberOfItems32SampleCategory", "Demonstrates usage of the NumberOfItems32 performance counter type.", CCDC );
      return true;
   }
   else
   {
      Console::WriteLine( "Category exists - NumberOfItems32SampleCategory" );
      return false;
   }
}

void CreateCounters( PerformanceCounter^% PC )
{
   // Create the counter.
   PC = gcnew PerformanceCounter( "NumberOfItems32SampleCategory","NumberOfItems32Sample",false );
   PC->RawValue = 0;
}

void CollectSamples( ArrayList^ samplesList, PerformanceCounter^ PC )
{
   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 );
      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 ]) ) );
   }
}

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

NumberOfItems64

#using <System.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
float MyComputeCounterValue( CounterSample s0, CounterSample s1 )
{
   float counterValue = (float)s1.RawValue;
   return counterValue;
}


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

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

      // Add the counter.
      CounterCreationData^ NOI64 = gcnew CounterCreationData;
      NOI64->CounterType = PerformanceCounterType::NumberOfItems64;
      NOI64->CounterName = "NumberOfItems64Sample";
      CCDC->Add( NOI64 );

      // Create the category.
      PerformanceCounterCategory::Create( "NumberOfItems64SampleCategory", "Demonstrates usage of the NumberOfItems64 performance counter type.", CCDC );
      return true;
   }
   else
   {
      Console::WriteLine( "Category exists - NumberOfItems64SampleCategory" );
      return false;
   }
}

void CreateCounters( PerformanceCounter^% PC )
{
   // Create the counters.
   PC = gcnew PerformanceCounter( "NumberOfItems64SampleCategory","NumberOfItems64Sample",false );
   PC->RawValue = 0;
}

void CollectSamples( ArrayList^ samplesList, PerformanceCounter^ PC )
{
   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 );
      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;
   SetupCategory();
   CreateCounters( PC );
   CollectSamples( samplesList, PC );
   CalculateResults( samplesList );
}

SampleFraction

No hay ningún ejemplo de código disponible o este idioma no es compatible.

RateOfCountsPerSecond32

#using <System.dll>

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

//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
//    PERF_COUNTER_COUNTER
//    Description     - This counter type shows the average number of operations completed
//        during each second of the sample interval. Counters of this type
//        measure time in ticks of the system clock. The F variable represents
//        the number of ticks per second. The value of F is factored into the
//        equation so that the result can be displayed in seconds.
//
//    Generic type - Difference
//
//    Formula - (N1 - N0) / ( (D1 - D0) / F), where the numerator (N) represents the number
//        of operations performed during the last sample interval, the denominator
//        (D) represents the number of ticks elapsed during the last sample
//        interval, and F is the frequency of the ticks.
//
//         Average - (Nx - N0) / ((Dx - D0) / F) 
//
//       Example - System\ File Read Operations/sec 
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
float MyComputeCounterValue( CounterSample s0, CounterSample s1 )
{
   float numerator = (float)(s1.RawValue - s0.RawValue);
   float denomenator = (float)(s1.TimeStamp - s0.TimeStamp) / (float)s1.SystemFrequency;
   float counterValue = numerator / denomenator;
   return counterValue;
}


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

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

      // Add the counter.
      CounterCreationData^ rateOfCounts32 = gcnew CounterCreationData;
      rateOfCounts32->CounterType = PerformanceCounterType::RateOfCountsPerSecond32;
      rateOfCounts32->CounterName = "RateOfCountsPerSecond32Sample";
      CCDC->Add( rateOfCounts32 );

      // Create the category.
      PerformanceCounterCategory::Create( "RateOfCountsPerSecond32SampleCategory", "Demonstrates usage of the RateOfCountsPerSecond32 performance counter type.", CCDC );
      return true;
   }
   else
   {
      Console::WriteLine( "Category exists - RateOfCountsPerSecond32SampleCategory" );
      return false;
   }
}

void CreateCounters( PerformanceCounter^% PC )
{
   // Create the counter.
   PC = gcnew PerformanceCounter( "RateOfCountsPerSecond32SampleCategory","RateOfCountsPerSecond32Sample",false );
   PC->RawValue = 0;
}

void CollectSamples( ArrayList^ samplesList, PerformanceCounter^ PC )
{
   Random^ r = gcnew Random( DateTime::Now.Millisecond );

   // Initialize the performance counter.
   PC->NextSample();

   // Loop for the samples.
   for ( int j = 0; j < 100; j++ )
   {
      int value = r->Next( 1, 10 );
      PC->IncrementBy( value );
      Console::Write( "{0} = {1}", j, value );
      if ( (j % 10) == 9 )
      {
         Console::WriteLine( ";       NextValue() = {0}", PC->NextValue() );
         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;
   SetupCategory();
   CreateCounters( PC );
   CollectSamples( samplesList, PC );
   CalculateResults( samplesList );
}

RateOfCountsPerSecond64

#using <System.dll>

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

//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
//    PERF_COUNTER_COUNTER
//    Description     - This counter type shows the average number of operations completed
//        during each second of the sample interval. Counters of this type
//        measure time in ticks of the system clock. The F variable represents
//        the number of ticks per second. The value of F is factored into the
//        equation so that the result can be displayed in seconds.
//
//    Generic type - Difference
//
//    Formula - (N1 - N0) / ( (D1 - D0) / F), where the numerator (N) represents the number
//        of operations performed during the last sample interval, the denominator
//        (D) represents the number of ticks elapsed during the last sample
//        interval, and F is the frequency of the ticks.
//
//    Average - (Nx - N0) / ((Dx - D0) / F) 
//
//  Example - System\ File Read Operations/sec 
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
float MyComputeCounterValue( CounterSample s0, CounterSample s1 )
{
   float numerator = (float)(s1.RawValue - s0.RawValue);
   float denomenator = (float)(s1.TimeStamp - s0.TimeStamp) / (float)s1.SystemFrequency;
   float counterValue = numerator / denomenator;
   return counterValue;
}

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

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

      // Add the counter.
      CounterCreationData^ rateOfCounts64 = gcnew CounterCreationData;
      rateOfCounts64->CounterType = PerformanceCounterType::RateOfCountsPerSecond64;
      rateOfCounts64->CounterName = "RateOfCountsPerSecond64Sample";
      CCDC->Add( rateOfCounts64 );

      // Create the category.
      PerformanceCounterCategory::Create( "RateOfCountsPerSecond64SampleCategory", "Demonstrates usage of the RateOfCountsPerSecond64 performance counter type.", CCDC );
      return true;
   }
   else
   {
      Console::WriteLine( "Category exists - RateOfCountsPerSecond64SampleCategory" );
      return false;
   }
}

void CreateCounters( PerformanceCounter^% PC )
{
   // Create the counter.
   PC = gcnew PerformanceCounter( "RateOfCountsPerSecond64SampleCategory","RateOfCountsPerSecond64Sample",false );
   PC->RawValue = 0;
}

void CollectSamples( ArrayList^ samplesList, PerformanceCounter^ PC )
{
   Random^ r = gcnew Random( DateTime::Now.Millisecond );

   // Initialize the performance counter.
   PC->NextSample();

   // Loop for the samples.
   for ( int j = 0; j < 100; j++ )
   {
      int value = r->Next( 1, 10 );
      PC->IncrementBy( value );
      Console::Write( "{0} = {1}", j, value );
      if ( (j % 10) == 9 )
      {
         Console::WriteLine( ";       NextValue() = {0}", PC->NextValue() );
         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;
   SetupCategory();
   CreateCounters( PC );
   CollectSamples( samplesList, PC );
   CalculateResults( samplesList );
}

RawFraction

#using <System.dll>

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

//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// Formula from MSDN -
//      Description - This counter type shows the ratio of a subset to its set as a percentage.
//            For example, it compares the number of bytes in use on a disk to the
//            total number of bytes on the disk. Counters of this type display the 
//            current percentage only, not an average over time.
//
// Generic type - Instantaneous, Percentage 
//        Formula - (N0 / D0), where D represents a measured attribute and N represents one
//            component of that attribute.
//
//        Average - SUM (N / D) /x 
//        Example - Paging File\% Usage Peak
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
float MyComputeCounterValue( CounterSample rfSample )
{
   float numerator = (float)rfSample.RawValue;
   float denomenator = (float)rfSample.BaseValue;
   float counterValue = (numerator / denomenator) * 100;
   return counterValue;
}


// Output information about the counter sample.
void OutputSample( CounterSample s )
{
   Console::WriteLine( "+++++++++++" );
   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( "++++++++++++++++++++++" );
}

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

      // Add the counter.
      CounterCreationData^ rf = gcnew CounterCreationData;
      rf->CounterType = PerformanceCounterType::RawFraction;
      rf->CounterName = "RawFractionSample";
      CCDC->Add( rf );

      // Add the base counter.
      CounterCreationData^ rfBase = gcnew CounterCreationData;
      rfBase->CounterType = PerformanceCounterType::RawBase;
      rfBase->CounterName = "RawFractionSampleBase";
      CCDC->Add( rfBase );

      // Create the category.
      PerformanceCounterCategory::Create( "RawFractionSampleCategory", "Demonstrates usage of the RawFraction performance counter type.", CCDC );
      return true;
   }
   else
   {
      Console::WriteLine( "Category exists - RawFractionSampleCategory" );
      return false;
   }
}

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

   // Create the counters.
   PC = gcnew PerformanceCounter( "RawFractionSampleCategory","RawFractionSample",false );
   BPC = gcnew PerformanceCounter( "RawFractionSampleCategory","RawFractionSampleBase",false );
   PC->RawValue = 0;
   BPC->RawValue = 0;
}

void CollectSamples( ArrayList^ samplesList, PerformanceCounter^ PC, PerformanceCounter^ BPC )
{
   Random^ r = gcnew Random( DateTime::Now.Millisecond );

   // Initialize the performance counter.
   PC->NextSample();

   // Loop for the samples.
   for ( int j = 0; j < 100; j++ )
   {
      int value = r->Next( 1, 10 );
      Console::Write( "{0} = {1}", j, value );

      // Increment the base every time, because the counter measures the number 
      // of high hits (raw fraction value) against all the hits (base value).
      BPC->Increment();

      // Get the % of samples that are 9 or 10 out of all the samples taken.
      if ( value >= 9 )
            PC->Increment();

      // Copy out the next value every ten times around the loop.
      if ( (j % 10) == 9 )
      {
         Console::WriteLine( ";       NextValue() = {0}", PC->NextValue() );
         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; i++ )
   {

      // Output the sample.
      OutputSample(  *safe_cast<CounterSample^>(samplesList[ i ]) );

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

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

   }
}

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
Volver al principio
Mostrar: