PerformanceCounterType PerformanceCounterType PerformanceCounterType PerformanceCounterType Enum

Definizione

Specifica la formula utilizzata per calcolare il metodo NextValue() di un'istanza di PerformanceCounter.Specifies the formula used to calculate the NextValue() method for a PerformanceCounter instance.

public enum class PerformanceCounterType
[System.ComponentModel.TypeConverter(typeof(System.Diagnostics.AlphabeticalEnumConverter))]
public enum PerformanceCounterType
type PerformanceCounterType = 
Public Enum PerformanceCounterType
Ereditarietà
PerformanceCounterTypePerformanceCounterTypePerformanceCounterTypePerformanceCounterType
Attributi

Campi

AverageBase AverageBase AverageBase AverageBase 1073939458

Un contatore di base utilizzato nel calcolo delle medie temporali o numeriche, ad esempio AverageTimer32 e AverageCount64 .A base counter that is used in the calculation of time or count averages, such as AverageTimer32 and AverageCount64. Memorizza il denominatore per il calcolo di un contatore con il quale presentare un "tempo per operazione" o un "numero per operazione".Stores the denominator for calculating a counter to present "time per operation" or "count per operation".

AverageCount64 AverageCount64 AverageCount64 AverageCount64 1073874176

Un contatore di media che mostra il numero di elementi elaborati, in media, durante un'operazione.An average counter that shows how many items are processed, on average, during an operation. I contatori di questo tipo visualizzano un rapporto tra gli elementi elaborati e il numero di operazioni completate.Counters of this type display a ratio of the items processed to the number of operations completed. Il rapporto viene calcolato confrontando il numero di elementi elaborati durante l'ultimo intervallo e il numero di operazioni completate durante l'ultimo intervallo.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. I contatori di questo tipo includono Disco fisico\Media byte/trasf. discoCounters of this type include PhysicalDisk\ Avg. Disk Bytes/Transfer.

AverageTimer32 AverageTimer32 AverageTimer32 AverageTimer32 805438464

Un contatore di media che misura il tempo necessario, in media, per completare un processo o un'operazione.An average counter that measures the time it takes, on average, to complete a process or operation. I contatori di questo tipo visualizzano un rapporto tra il tempo totale trascorso dell'intervallo di campionamento e il numero di processi o operazioni completate durante tale periodo.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. Questo tipo di contatore misura il tempo in segni di graduazione dell'orologio di sistema.This counter type measures time in ticks of the system clock. I contatori di questo tipo includono Disco fisico\Media secondi/trasf. discoCounters of this type include PhysicalDisk\ Avg. Disk sec/Transfer.

CounterDelta32 CounterDelta32 CounterDelta32 CounterDelta32 4195328

Un contatore di differenza che mostra la variazione nell'attributo misurato tra i due intervalli di campionamento più recenti.A difference counter that shows the change in the measured attribute between the two most recent sample intervals.

CounterDelta64 CounterDelta64 CounterDelta64 CounterDelta64 4195584

Un contatore di differenza che mostra la variazione nell'attributo misurato tra i due intervalli di campionamento più recenti.A difference counter that shows the change in the measured attribute between the two most recent sample intervals. È identico al tipo di contatore CounterDelta32, ad eccezione del fatto che usa campi di dimensioni maggiori per poter contenere valori più grandi.It is the same as the CounterDelta32 counter type except that is uses larger fields to accommodate larger values.

CounterMultiBase CounterMultiBase CounterMultiBase CounterMultiBase 1107494144

Un contatore di base che indica il numero di elementi campionati.A base counter that indicates the number of items sampled. Esso viene usato come denominatore nei calcoli per ottenere una media tra gli elementi campionati durante il rilevamento dei tempi di più elementi simili.It is used as the denominator in the calculations to get an average among the items sampled when taking timings of multiple, but similar items. Utilizzato con CounterMultiTimer, CounterMultiTimerInverse, CounterMultiTimer100Ns e CounterMultiTimer100NsInverse.Used with CounterMultiTimer, CounterMultiTimerInverse, CounterMultiTimer100Ns, and CounterMultiTimer100NsInverse.

CounterMultiTimer CounterMultiTimer CounterMultiTimer CounterMultiTimer 574686464

Un contatore di percentuale che visualizza il tempo attivo di uno o più componenti come percentuale del tempo totale dell'intervallo di campionamento.A percentage counter that displays the active time of one or more components as a percentage of the total time of the sample interval. Poiché il numeratore registra il tempo attivo dei componenti che funzionano contemporaneamente, la percentuale risultante può superare il 100 percento.Because the numerator records the active time of components operating simultaneously, the resulting percentage can exceed 100 percent. Questo tipo di contatore si differenzia da CounterMultiTimer100Ns in quanto misura il tempo in unità di segni di graduazione del timer delle prestazioni di sistema, invece che in unità di 100 nanosecondi.This counter type differs from CounterMultiTimer100Ns in that it measures time in units of ticks of the system performance timer, rather than in 100 nanosecond units. Questo tipo di contatore è un multitimer.This counter type is a multitimer.

CounterMultiTimer100Ns CounterMultiTimer100Ns CounterMultiTimer100Ns CounterMultiTimer100Ns 575735040

Un contatore di percentuale che mostra il tempo attivo di uno o più componenti come percentuale del tempo totale dell'intervallo di campionamento.A percentage counter that shows the active time of one or more components as a percentage of the total time of the sample interval. Misura il tempo in unità di 100 nanosecondi (ns).It measures time in 100 nanosecond (ns) units. Questo tipo di contatore è un multitimer.This counter type is a multitimer.

CounterMultiTimer100NsInverse CounterMultiTimer100NsInverse CounterMultiTimer100NsInverse CounterMultiTimer100NsInverse 592512256

Un contatore di percentuale che mostra il tempo attivo di uno o più componenti come percentuale del tempo totale dell'intervallo di campionamento.A percentage counter that shows the active time of one or more components as a percentage of the total time of the sample interval. I contatori di questo tipo misurano il tempo in unità di 100 nanosecondi (ns).Counters of this type measure time in 100 nanosecond (ns) units. Essi derivano il tempo attivo misurando il tempo durante il quale i componenti non erano attivi e sottraendo il risultato dalla moltiplicazione di 100 percento per il numero di oggetti monitorati.They derive the active time by measuring the time that the components were not active and subtracting the result from multiplying 100 percent by the number of objects monitored. Questo tipo di contatore è un multitimer inverso.This counter type is an inverse multitimer.

CounterMultiTimerInverse CounterMultiTimerInverse CounterMultiTimerInverse CounterMultiTimerInverse 591463680

Un contatore di percentuale che mostra il tempo attivo di uno o più componenti come percentuale del tempo totale dell'intervallo di campionamento.A percentage counter that shows the active time of one or more components as a percentage of the total time of the sample interval. Esso deriva il tempo attivo misurando il tempo durante il quale i componenti non erano attivi e sottraendo il risultato dal calcolo del 100 percento del numero di oggetti monitorati.It derives the active time by measuring the time that the components were not active and subtracting the result from 100 percent by the number of objects monitored. Questo tipo di contatore è un multitimer inverso.This counter type is an inverse multitimer. Si differenzia da CounterMultiTimer100NsInverse in quanto misura il tempo in unità di segni di graduazione del timer delle prestazioni di sistema, invece che in unità di 100 nanosecondi.It differs from CounterMultiTimer100NsInverse in that it measures time in units of ticks of the system performance timer, rather than in 100 nanosecond units.

CounterTimer CounterTimer CounterTimer CounterTimer 541132032

Un contatore di percentuale che mostra il tempo medio durante il quale un componente è attivo come percentuale del tempo di campionamento totale.A percentage counter that shows the average time that a component is active as a percentage of the total sample time.

CounterTimerInverse CounterTimerInverse CounterTimerInverse CounterTimerInverse 557909248

Un contatore di percentuale che visualizza la percentuale media di tempo attivo osservato durante l'intervallo di campionamento.A percentage counter that displays the average percentage of active time observed during sample interval. Il valore di questi contatori viene calcolato monitorando la percentuale di tempo durante la quale il servizio era inattivo e sottraendo tale valore da 100 percento.The value of these counters is calculated by monitoring the percentage of time that the service was inactive and then subtracting that value from 100 percent. Si tratta di un tipo di contatore inverso.This is an inverse counter type. È identico a CounterTimer100NsInv ad eccezione del fatto che misura il tempo in unità di segni di graduazione del timer delle prestazioni di sistema, invece che in unità di 100 nanosecondi.It is the same as CounterTimer100NsInv, except that it measures time in units of ticks of the system performance timer rather than in 100 nanosecond units.

CountPerTimeInterval32 CountPerTimeInterval32 CountPerTimeInterval32 CountPerTimeInterval32 4523008

Un contatore di media progettato per monitorare la lunghezza media di una coda ad una risorsa nel tempo.An average counter designed to monitor the average length of a queue to a resource over time. Mostra la differenza tra le lunghezze di coda osservate durante gli ultimi due intervalli di campionamento divisa per la durata dell'intervallo.It shows the difference between the queue lengths observed during the last two sample intervals divided by the duration of the interval. Questo tipo di contatore viene generalmente utilizzato per rilevare il numero di elementi in coda o in attesa.This type of counter is typically used to track the number of items that are queued or waiting.

CountPerTimeInterval64 CountPerTimeInterval64 CountPerTimeInterval64 CountPerTimeInterval64 4523264

Un contatore di media che consente di monitorare la lunghezza media di una coda ad una risorsa nel tempo.An average counter that monitors the average length of a queue to a resource over time. I contatori di questo tipo mostrano la differenza tra le lunghezze di coda osservate durante gli ultimi due intervalli di campionamento, divisa per la durata dell'intervallo.Counters of this type display the difference between the queue lengths observed during the last two sample intervals, divided by the duration of the interval. Questo tipo di contatore è identico a CountPerTimeInterval32 ad eccezione del fatto che usa campi di dimensioni maggiori per poter contenere valori più grandi.This counter type is the same as CountPerTimeInterval32 except that it uses larger fields to accommodate larger values. Questo tipo di contatore viene generalmente utilizzato per rilevare un numero molto ampio di elementi in coda o in attesa.This type of counter is typically used to track a high-volume or very large number of items that are queued or waiting.

ElapsedTime ElapsedTime ElapsedTime ElapsedTime 807666944

Un timer di differenza che mostra il tempo totale trascorso tra l'avvio del componente o del processo ed il momento in cui questo valore viene calcolato.A difference timer that shows the total time between when the component or process started and the time when this value is calculated. I contatori di questo tipo includono Sistema\Tempo di funzionamento sistema.Counters of this type include System\ System Up Time.

NumberOfItems32 NumberOfItems32 NumberOfItems32 NumberOfItems32 65536

Un contatore istantaneo che mostra il valore osservato più recentemente.An instantaneous counter that shows the most recently observed value. Utilizzato per gestire, ad esempio, un semplice conteggio di elementi o di operazioni.Used, for example, to maintain a simple count of items or operations. I contatori di questo tipo includono Memoria\Byte disponibili.Counters of this type include Memory\Available Bytes.

NumberOfItems64 NumberOfItems64 NumberOfItems64 NumberOfItems64 65792

Un contatore istantaneo che mostra il valore osservato più recentemente.An instantaneous counter that shows the most recently observed value. Utilizzato per gestire, ad esempio, un semplice conteggio di un numero molto ampio di elementi o di operazioni.Used, for example, to maintain a simple count of a very large number of items or operations. È identico a NumberOfItems32 ad eccezione del fatto che usa campi di dimensioni maggiori per poter contenere valori più grandi.It is the same as NumberOfItems32 except that it uses larger fields to accommodate larger values.

NumberOfItemsHEX32 NumberOfItemsHEX32 NumberOfItemsHEX32 NumberOfItemsHEX32 0

Un contatore istantaneo che mostra il valore osservato più recentemente in formato esadecimale.An instantaneous counter that shows the most recently observed value in hexadecimal format. Utilizzato per gestire, ad esempio, un semplice conteggio di elementi o di operazioni.Used, for example, to maintain a simple count of items or operations.

NumberOfItemsHEX64 NumberOfItemsHEX64 NumberOfItemsHEX64 NumberOfItemsHEX64 256

Un contatore istantaneo che mostra il valore osservato più recentemente.An instantaneous counter that shows the most recently observed value. Utilizzato per gestire, ad esempio, un semplice conteggio di un numero molto ampio di elementi o di operazioni.Used, for example, to maintain a simple count of a very large number of items or operations. È identico a NumberOfItemsHEX32 ad eccezione del fatto che usa campi di dimensioni maggiori per poter contenere valori più grandi.It is the same as NumberOfItemsHEX32 except that it uses larger fields to accommodate larger values.

RateOfCountsPerSecond32 RateOfCountsPerSecond32 RateOfCountsPerSecond32 RateOfCountsPerSecond32 272696320

Un contatore di differenza che mostra il numero medio di operazioni completate durante ogni secondo dell'intervallo di campionamento.A difference counter that shows the average number of operations completed during each second of the sample interval. I contatori di questo tipo misurano il tempo in segni di graduazione dell'orologio di sistema.Counters of this type measure time in ticks of the system clock. I contatori di questo tipo includono Sistema\Operazioni lettura file/sec.Counters of this type include System\ File Read Operations/sec.

RateOfCountsPerSecond64 RateOfCountsPerSecond64 RateOfCountsPerSecond64 RateOfCountsPerSecond64 272696576

Un contatore di differenza che mostra il numero medio di operazioni completate durante ogni secondo dell'intervallo di campionamento.A difference counter that shows the average number of operations completed during each second of the sample interval. I contatori di questo tipo misurano il tempo in segni di graduazione dell'orologio di sistema.Counters of this type measure time in ticks of the system clock. Questo tipo di contatore è identico al tipo RateOfCountsPerSecond32, ma usa campi di dimensioni maggiori per poter contenere valori più grandi al fine di rilevare un numero molto ampio di elementi o operazioni al secondo, quali ad esempio la velocità di trasmissione in byte.This counter type is the same as the RateOfCountsPerSecond32 type, but it uses larger fields to accommodate larger values to track a high-volume number of items or operations per second, such as a byte-transmission rate. I contatori di questo tipo includono Sistema\Byte di file letti/sec.Counters of this type include System\ File Read Bytes/sec.

RawBase RawBase RawBase RawBase 1073939459

Un contatore di base che memorizza il denominatore di un contatore che presenta una frazione aritmetica generale.A base counter that stores the denominator of a counter that presents a general arithmetic fraction. Verificare che questo valore sia maggiore di zero prima di utilizzarlo come denominatore nel calcolo di un valore RawFraction.Check that this value is greater than zero before using it as the denominator in a RawFraction value calculation.

RawFraction RawFraction RawFraction RawFraction 537003008

Un contatore di percentuale istantaneo che mostra il rapporto fra un sottoinsieme e il suo insieme sotto forma di percentuale.An instantaneous percentage counter that shows the ratio of a subset to its set as a percentage. Esso confronta, ad esempio, il numero di byte utilizzati su un disco con il numero totale di byte su disco.For example, it compares the number of bytes in use on a disk to the total number of bytes on the disk. I contatori di questo tipo visualizzano solo la percentuale corrente e non una media nel tempo.Counters of this type display the current percentage only, not an average over time. I contatori di questo tipo includono File di paging\Utilizzo % massimo.Counters of this type include Paging File\% Usage Peak.

SampleBase SampleBase SampleBase SampleBase 1073939457

Un contatore di base che memorizza il numero di interruzioni del campione che hanno avuto luogo e usato come denominatore nella frazione di campionamento.A base counter that stores the number of sampling interrupts taken and is used as a denominator in the sampling fraction. La frazione di campionamento è il numero di campioni che corrispondevano a 1 (o true ) nel caso di un'interruzione del campione.The sampling fraction is the number of samples that were 1 (or true) for a sample interrupt. Verificare che questo valore sia maggiore di zero prima di utilizzarlo come denominatore nel calcolo di SampleFraction.Check that this value is greater than zero before using it as the denominator in a calculation of SampleFraction.

SampleCounter SampleCounter SampleCounter SampleCounter 4260864

Un contatore di media che mostra il numero medio di operazioni completate in un secondo.An average counter that shows the average number of operations completed in one second. Quando un contatore di questo tipo campiona i dati, ogni interruzione del campione restituisce uno o zero.When a counter of this type samples the data, each sampling interrupt returns one or zero. I dati del contatore costituiscono il numero di quelli campionati.The counter data is the number of ones that were sampled. Misura il tempo in unità di segni di graduazione del timer delle prestazioni di sistema.It measures time in units of ticks of the system performance timer.

SampleFraction SampleFraction SampleFraction SampleFraction 549585920

Un contatore di percentuale che mostra il rapporto medio tra gli accessi e tutte le operazioni durante gli ultimi due intervalli di campionamento.A percentage counter that shows the average ratio of hits to all operations during the last two sample intervals. I contatori di questo tipo includono Cache\Letture in pre-scrittura trovate %.Counters of this type include Cache\Pin Read Hits %.

Timer100Ns Timer100Ns Timer100Ns Timer100Ns 542180608

Un contatore di percentuale che mostra il tempo attivo di un componente come percentuale del tempo totale trascorso dell'intervallo di campionamento.A percentage counter that shows the active time of a component as a percentage of the total elapsed time of the sample interval. Misura il tempo in unità di 100 nanosecondi (ns).It measures time in units of 100 nanoseconds (ns). I contatori di questo tipo sono progettati per misurare l'attività di un componente per volta.Counters of this type are designed to measure the activity of one component at a time. I contatori di questo tipo includono Processore% Tempo utente.Counters of this type include Processor\ % User Time.

Timer100NsInverse Timer100NsInverse Timer100NsInverse Timer100NsInverse 558957824

Un contatore di percentuale che mostra la percentuale media di tempo attivo osservato durante l'intervallo di campionamento.A percentage counter that shows the average percentage of active time observed during the sample interval. Si tratta di un contatore inverso.This is an inverse counter. I contatori di questo tipo includono Processore% Tempo processore.Counters of this type include Processor\ % Processor Time.

Esempi

Negli esempi seguenti vengono illustrati diversi tipi di contatori nell' PerformanceCounterType enumerazione.The following examples demonstrate several of the counter types in the PerformanceCounterType enumeration.

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

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class App {

    private static PerformanceCounter avgCounter64Sample;
    private static PerformanceCounter avgCounter64SampleBase;

    public static void Main()
    {
    
        ArrayList samplesList = new ArrayList();

        // If the category does not exist, create the category and exit.
        // Performance counters should not be created and immediately used.
        // There is a latency time to enable the counters, they should be created
        // prior to executing the application that uses the counters.
        // Execute this sample a second time to use the category.
        if (SetupCategory())
            return;
        CreateCounters();
        CollectSamples(samplesList);
        CalculateResults(samplesList);

    }

    private static bool SetupCategory()
    {
        if ( !PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") ) 
        {

            CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData averageCount64 = new CounterCreationData();
            averageCount64.CounterType = PerformanceCounterType.AverageCount64;
            averageCount64.CounterName = "AverageCounter64Sample";
            counterDataCollection.Add(averageCount64);

            // Add the base counter.
            CounterCreationData averageCount64Base = new CounterCreationData();
            averageCount64Base.CounterType = PerformanceCounterType.AverageBase;
            averageCount64Base.CounterName = "AverageCounter64SampleBase";
            counterDataCollection.Add(averageCount64Base);

            // Create the category.
            PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
                "Demonstrates usage of the AverageCounter64 performance counter type.",
                PerformanceCounterCategoryType.SingleInstance, counterDataCollection);

            return(true);
        }
        else
        {
            Console.WriteLine("Category exists - AverageCounter64SampleCategory");
            return(false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counters.

        avgCounter64Sample = new PerformanceCounter("AverageCounter64SampleCategory", 
            "AverageCounter64Sample", 
            false);


        avgCounter64SampleBase = new PerformanceCounter("AverageCounter64SampleCategory", 
            "AverageCounter64SampleBase", 
            false);

        avgCounter64Sample.RawValue=0;
        avgCounter64SampleBase.RawValue=0;
    }
    private static void CollectSamples(ArrayList samplesList)
    {

        Random r = new Random( DateTime.Now.Millisecond );

        // Loop for the samples.
        for (int j = 0; j < 100; j++) 
        {

            int value = r.Next(1, 10);
            Console.Write(j + " = " + value);

            avgCounter64Sample.IncrementBy(value);

            avgCounter64SampleBase.Increment();

            if ((j % 10) == 9) 
            {
                OutputSample(avgCounter64Sample.NextSample());
                samplesList.Add( avgCounter64Sample.NextSample() );
            }
            else
                Console.WriteLine();

            System.Threading.Thread.Sleep(50);
        }

    }

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

            // Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " +
                CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i],
                (CounterSample)samplesList[i+1]) );

            // Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " + 
                MyComputeCounterValue((CounterSample)samplesList[i],
                (CounterSample)samplesList[i+1]) );

        }
    }

    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    //    Description - This counter type shows how many items are processed, on average,
    //        during an operation. Counters of this type display a ratio of the items 
    //        processed (such as bytes sent) to the number of operations completed. The  
    //        ratio is calculated by comparing the number of items processed during the 
    //        last interval to the number of operations completed during the last interval. 
    // Generic type - Average
    //      Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number 
    //        of items processed during the last sample interval and the denominator (D) 
    //        represents the number of operations completed during the last two sample 
    //        intervals. 
    //    Average (Nx - N0) / (Dx - D0)  
    //    Example PhysicalDisk\ Avg. Disk Bytes/Transfer 
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
    {
        Single numerator = (Single)s1.RawValue - (Single)s0.RawValue;
        Single denomenator = (Single)s1.BaseValue - (Single)s0.BaseValue;
        Single counterValue = numerator / denomenator;
        return(counterValue);
    }

    // Output information about the counter sample.
    private static void OutputSample(CounterSample s)
    {
        Console.WriteLine("\r\n+++++++++++");
        Console.WriteLine("Sample values - \r\n");
        Console.WriteLine("   BaseValue        = " + s.BaseValue);
        Console.WriteLine("   CounterFrequency = " + s.CounterFrequency);
        Console.WriteLine("   CounterTimeStamp = " + s.CounterTimeStamp);
        Console.WriteLine("   CounterType      = " + s.CounterType);
        Console.WriteLine("   RawValue         = " + s.RawValue);
        Console.WriteLine("   SystemFrequency  = " + s.SystemFrequency);
        Console.WriteLine("   TimeStamp        = " + s.TimeStamp);
        Console.WriteLine("   TimeStamp100nSec = " + s.TimeStamp100nSec);
        Console.WriteLine("++++++++++++++++++++++");
    }
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class App

    Private Shared avgCounter64Sample As PerformanceCounter
    Private Shared avgCounter64SampleBase As PerformanceCounter


    Public Shared Sub Main()

        Dim samplesList As 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 counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If

    End Sub

    Private Shared Function SetupCategory() As Boolean
        If Not PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") Then

            Dim counterDataCollection As New CounterCreationDataCollection()

            ' Add the counter.
            Dim averageCount64 As New CounterCreationData()
            averageCount64.CounterType = PerformanceCounterType.AverageCount64
            averageCount64.CounterName = "AverageCounter64Sample"
            counterDataCollection.Add(averageCount64)

            ' Add the base counter.
            Dim averageCount64Base As New CounterCreationData()
            averageCount64Base.CounterType = PerformanceCounterType.AverageBase
            averageCount64Base.CounterName = "AverageCounter64SampleBase"
            counterDataCollection.Add(averageCount64Base)

            ' Create the category.
            PerformanceCounterCategory.Create("AverageCounter64SampleCategory", _
               "Demonstrates usage of the AverageCounter64 performance counter type.", _
                      PerformanceCounterCategoryType.SingleInstance, counterDataCollection)

            Return True
        Else
            Console.WriteLine("Category exists - AverageCounter64SampleCategory")
            Return False
        End If
    End Function 'SetupCategory

    Private Shared Sub CreateCounters()
        ' Create the counters.

        avgCounter64Sample = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64Sample", False)

        avgCounter64SampleBase = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64SampleBase", False)

        avgCounter64Sample.RawValue = 0
        avgCounter64SampleBase.RawValue = 0
    End Sub

    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

        Dim r As New Random(DateTime.Now.Millisecond)

        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99

            Dim value As Integer = r.Next(1, 10)
            Console.Write(j.ToString() + " = " + value.ToString())

            avgCounter64Sample.IncrementBy(value)

            avgCounter64SampleBase.Increment()

            If j Mod 10 = 9 Then
                OutputSample(avgCounter64Sample.NextSample())
                samplesList.Add(avgCounter64Sample.NextSample())
            Else
                Console.WriteLine()
            End If
            System.Threading.Thread.Sleep(50)
        Next j
    End Sub

    Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
        Dim i As Integer
        For i = 0 To (samplesList.Count - 1) - 1
            ' Output the sample.
            OutputSample(CType(samplesList(i), CounterSample))
            OutputSample(CType(samplesList((i + 1)), CounterSample))

            ' Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())

            ' Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
        Next i
    End Sub

    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '	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 Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim numerator As [Single] = CType(s1.RawValue, [Single]) - CType(s0.RawValue, [Single])
        Dim denomenator As [Single] = CType(s1.BaseValue, [Single]) - CType(s0.BaseValue, [Single])
        Dim counterValue As [Single] = numerator / denomenator
        Return counterValue
    End Function 'MyComputeCounterValue

    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
        Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
        Console.WriteLine(("   BaseValue        = " + s.BaseValue.ToString()))
        Console.WriteLine(("   CounterFrequency = " + s.CounterFrequency.ToString()))
        Console.WriteLine(("   CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
        Console.WriteLine(("   CounterType      = " + s.CounterType.ToString()))
        Console.WriteLine(("   RawValue         = " + s.RawValue.ToString()))
        Console.WriteLine(("   SystemFrequency  = " + s.SystemFrequency.ToString()))
        Console.WriteLine(("   TimeStamp        = " + s.TimeStamp.ToString()))
        Console.WriteLine(("   TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
        Console.WriteLine("++++++++++++++++++++++")
    End Sub
End Class 'App

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

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Runtime.InteropServices;

public class App
{

    private static PerformanceCounter PC;
    private static PerformanceCounter BPC;

    private const String categoryName = "AverageTimer32SampleCategory";
    private const String counterName = "AverageTimer32Sample";
    private const String baseCounterName = "AverageTimer32SampleBase";

    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(categoryName))
        {

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData averageTimer32 = new CounterCreationData();
            averageTimer32.CounterType = PerformanceCounterType.AverageTimer32;
            averageTimer32.CounterName = counterName;
            CCDC.Add(averageTimer32);

            // Add the base counter.
            CounterCreationData averageTimer32Base = new CounterCreationData();
            averageTimer32Base.CounterType = PerformanceCounterType.AverageBase;
            averageTimer32Base.CounterName = baseCounterName;
            CCDC.Add(averageTimer32Base);

            // Create the category.
            PerformanceCounterCategory.Create(categoryName, 
                "Demonstrates usage of the AverageTimer32 performance counter type", 
                PerformanceCounterCategoryType.SingleInstance, CCDC);

            Console.WriteLine("Category created - " + categoryName);

            return (true);
        }
        else
        {
            Console.WriteLine("Category exists - " + categoryName);
            return (false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counters.
        PC = new PerformanceCounter(categoryName,
                 counterName,
                 false);

        BPC = new PerformanceCounter(categoryName,
            baseCounterName,
            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 i = 0; i < 10; i++)
        {

            PC.RawValue = Stopwatch.GetTimestamp();

            BPC.IncrementBy(10);

            System.Threading.Thread.Sleep(1000);

            Console.WriteLine("Next value = " + PC.NextValue().ToString());
            samplesList.Add(PC.NextSample());

        }

    }

    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 = " +
                CounterSample.Calculate((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]));

        }
    }



    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
    // 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 
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
    private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
    {
        Int64 n1 = s1.RawValue;
        Int64 n0 = s0.RawValue;
        ulong f = (ulong)s1.SystemFrequency;
        Int64 d1 = s1.BaseValue;
        Int64 d0 = s0.BaseValue;

        double numerator = (double)(n1 - n0);
        double denominator = (double)(d1 - d0);
        Single counterValue = (Single)((numerator / f) / denominator);
        return (counterValue);
    }

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

Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.InteropServices
Public Class App

    Private Const categoryName As String = "AverageTimer32SampleCategory"
    Private Const counterName As String = "AverageTimer32Sample"
    Private Const baseCounterName As String = "AverageTimer32SampleBase"

    Private Shared PC As PerformanceCounter
    Private Shared BPC As PerformanceCounter


    Public Shared Sub Main()
        Dim samplesList As New ArrayList()

        SetupCategory()
        CreateCounters()
        CollectSamples(samplesList)
        CalculateResults(samplesList)
    End Sub


    Private Shared Function SetupCategory() As Boolean

        If Not PerformanceCounterCategory.Exists(categoryName) Then

            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim averageTimer32 As New CounterCreationData()
            averageTimer32.CounterType = PerformanceCounterType.AverageTimer32
            averageTimer32.CounterName = counterName
            CCDC.Add(averageTimer32)

            ' Add the base counter.
            Dim averageTimer32Base As New CounterCreationData()
            averageTimer32Base.CounterType = PerformanceCounterType.AverageBase
            averageTimer32Base.CounterName = baseCounterName
            CCDC.Add(averageTimer32Base)

            ' Create the category.
            PerformanceCounterCategory.Create( _
               categoryName, _
               "Demonstrates usage of the AverageTimer32 performance counter type", _
                 PerformanceCounterCategoryType.SingleInstance, CCDC)

            Console.WriteLine("Category created - " + categoryName)

            Return True
        Else
            Console.WriteLine(("Category exists - " + _
               categoryName))
            Return False
        End If
    End Function


    Private Shared Sub CreateCounters()
        ' Create the counters.
        PC = New PerformanceCounter(categoryName, _
              counterName, False)

        BPC = New PerformanceCounter(categoryName, _
              baseCounterName, False)

        PC.RawValue = 0
        BPC.RawValue = 0
    End Sub


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

        Dim r As New Random(DateTime.Now.Millisecond)

        ' Loop for the samples.
        Dim i As Integer
        For i = 0 To 9

            PC.RawValue = Stopwatch.GetTimeStamp()

            BPC.IncrementBy(10)

            System.Threading.Thread.Sleep(1000)
            Console.WriteLine(("Next value = " + PC.NextValue().ToString()))
            samplesList.Add(PC.NextSample())
        Next i
    End Sub


    Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
        Dim i As Integer
        Dim sample1 As CounterSample
        Dim sample2 As CounterSample
        For i = 0 To (samplesList.Count - 1) - 1
            ' Output the sample.
            sample1 = CType(samplesList(i), CounterSample)
            sample2 = CType(samplesList(i + 1), CounterSample)
            OutputSample(sample1)
            OutputSample(sample2)

            ' Use .NET to calculate the counter value.
            Console.WriteLine((".NET computed counter value = " _
               + CounterSample.Calculate(sample1, sample2).ToString()))

            ' Calculate the counter value manually.
            Console.WriteLine(("My computed counter value = " _
               + MyComputeCounterValue(sample1, sample2).ToString()))

        Next i
    End Sub


    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
    ' 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 
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
    Private Shared Function MyComputeCounterValue( _
    ByVal s0 As CounterSample, _
    ByVal s1 As CounterSample) As Single
        Dim n1 As Int64 = s1.RawValue
        Dim n0 As Int64 = s0.RawValue
        Dim f As Decimal = CType(s1.SystemFrequency, Decimal)
        Dim d1 As Int64 = s1.BaseValue
        Dim d0 As Int64 = s0.BaseValue

        Dim numerator As Double = System.Convert.ToDouble(n1 - n0)
        Dim denominator As Double = System.Convert.ToDouble(d1 - d0)
        Dim counterValue As Single = CType(numerator, Single)
        counterValue = counterValue / CType(f, Single)
        counterValue = counterValue / CType(denominator, Single)

        Return counterValue
    End Function


    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine("+++++++++++")
        Console.WriteLine("Sample values - " + ControlChars.Cr _
              + ControlChars.Lf)
        Console.WriteLine(("   CounterType      = " + _
              s.CounterType.ToString()))
        Console.WriteLine(("   RawValue         = " + _
              s.RawValue.ToString()))
        Console.WriteLine(("   BaseValue        = " _
              + s.BaseValue.ToString()))
        Console.WriteLine(("   CounterFrequency = " + _
              s.CounterFrequency.ToString()))
        Console.WriteLine(("   CounterTimeStamp = " + _
              s.CounterTimeStamp.ToString()))
        Console.WriteLine(("   SystemFrequency  = " + _
              s.SystemFrequency.ToString()))
        Console.WriteLine(("   TimeStamp        = " + _
              s.TimeStamp.ToString()))
        Console.WriteLine(("   TimeStamp100nSec = " + _
              s.TimeStamp100nSec.ToString()))
        Console.WriteLine("++++++++++++++++++++++")
    End Sub


End Class

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

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Runtime.InteropServices;

public class App 
{

    public static void Main()
    {	
        CollectSamples();
    }

   
    public static void CollectSamples()
    {
        const String categoryName = "ElapsedTimeSampleCategory";
        const String counterName = "ElapsedTimeSample";

        // 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 ( !PerformanceCounterCategory.Exists(categoryName) ) 
        {

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData ETimeData = new CounterCreationData();
            ETimeData.CounterType = PerformanceCounterType.ElapsedTime;
            ETimeData.CounterName = counterName;
            CCDC.Add(ETimeData);	   
		
            // Create the category.
            PerformanceCounterCategory.Create(categoryName,
                    "Demonstrates ElapsedTime performance counter usage.",
                PerformanceCounterCategoryType.SingleInstance, CCDC);
            // Return, rerun the application to make use of the new counters.
            return;

        }
        else
        {
            Console.WriteLine("Category exists - {0}", categoryName);
        }        

        // Create the performance counter.
        PerformanceCounter PC = new 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() = " + PC.NextValue().ToString());
                Console.WriteLine("Actual elapsed time = " + DateTime.Now.Subtract(Start).ToString());
                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 = " + DateTime.Now.Subtract(Start).ToString());
    }

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

Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.InteropServices

Public Class App

    Public Shared Sub Main()
        CollectSamples()
    End Sub

    Private Shared Sub CollectSamples()

        Dim categoryName As String = "ElapsedTimeSampleCategory"
        Dim counterName As String = "ElapsedTimeSample"

        If Not PerformanceCounterCategory.Exists(categoryName) Then

            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim ETimeData As New CounterCreationData()
            ETimeData.CounterType = PerformanceCounterType.ElapsedTime
            ETimeData.CounterName = counterName
            CCDC.Add(ETimeData)

            ' Create the category.
            PerformanceCounterCategory.Create(categoryName, _
               "Demonstrates ElapsedTime performance counter usage.", _
                   PerformanceCounterCategoryType.SingleInstance, CCDC)

        Else
            Console.WriteLine("Category exists - {0}", categoryName)
        End If

        ' Create the counter.
        Dim PC As PerformanceCounter
        PC = New PerformanceCounter(categoryName, counterName, False)

        ' Initialize the counter.
        PC.RawValue = Stopwatch.GetTimestamp()

        Dim Start As DateTime = DateTime.Now

        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99
            ' Output the values.
            If j Mod 10 = 9 Then
                Console.WriteLine(("NextValue() = " _
                    + PC.NextValue().ToString()))
                Console.WriteLine(("Actual elapsed time = " _
                    + DateTime.Now.Subtract(Start).ToString()))
                OutputSample(PC.NextSample())
            End If

            ' Reset the counter every 20th iteration.
            If j Mod 20 = 0 Then
                PC.RawValue = Stopwatch.GetTimestamp()
                Start = DateTime.Now
            End If
            System.Threading.Thread.Sleep(50)
        Next j

        Console.WriteLine(("Elapsed time = " + _
              DateTime.Now.Subtract(Start).ToString()))
    End Sub


    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++")

        Console.WriteLine("Sample values - " + ControlChars.Cr _
              + ControlChars.Lf)
        Console.WriteLine(("   BaseValue        = " _
              + s.BaseValue.ToString()))
        Console.WriteLine(("   CounterFrequency = " + _
              s.CounterFrequency.ToString()))
        Console.WriteLine(("   CounterTimeStamp = " + _
              s.CounterTimeStamp.ToString()))
        Console.WriteLine(("   CounterType      = " + _
              s.CounterType.ToString()))
        Console.WriteLine(("   RawValue         = " + _
              s.RawValue.ToString()))
        Console.WriteLine(("   SystemFrequency  = " + _
              s.SystemFrequency.ToString()))
        Console.WriteLine(("   TimeStamp        = " + _
              s.TimeStamp.ToString()))
        Console.WriteLine(("   TimeStamp100nSec = " + _
              s.TimeStamp100nSec.ToString()))

        Console.WriteLine("+++++++")
    End Sub
End Class

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 );
}
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class NumberOfItems64
{

	private static PerformanceCounter PC;

	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("NumberOfItems32SampleCategory") ) 
        {

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData NOI64 = new 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.",
                PerformanceCounterCategoryType.SingleInstance, CCDC);

            return(true);
        }
        else
        {
            Console.WriteLine("Category exists - NumberOfItems32SampleCategory");
            return(false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counter.
        PC = new PerformanceCounter("NumberOfItems32SampleCategory", 
			"NumberOfItems32Sample", 
			false);

        PC.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);

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

        }
    }
	

	//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
	//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
	private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
	{
		Single counterValue = s1.RawValue;
		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("++++++++++++++++++++++");
	}


	
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class NumberOfItems64

    Private Shared PC As PerformanceCounter


    Public Shared Sub Main()
        Dim samplesList As 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 counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If
    End Sub


    Private Shared Function SetupCategory() As Boolean
        If Not PerformanceCounterCategory.Exists("NumberOfItems32SampleCategory") Then

            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim NOI64 As New 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.", _
                      PerformanceCounterCategoryType.SingleInstance, CCDC)

            Return True
        Else
            Console.WriteLine("Category exists - NumberOfItems32SampleCategory")
            Return False
        End If
    End Function 'SetupCategory


    Private Shared Sub CreateCounters()
        ' Create the counter.
        PC = New PerformanceCounter("NumberOfItems32SampleCategory", "NumberOfItems32Sample", False)

        PC.RawValue = 0
    End Sub


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)



        Dim r As New Random(DateTime.Now.Millisecond)

        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99

            Dim value As Integer = r.Next(1, 10)
            Console.Write(j.ToString() + " = " + value.ToString())

            PC.IncrementBy(value)

            If j Mod 10 = 9 Then
                OutputSample(PC.NextSample())
                samplesList.Add(PC.NextSample())
            Else
                Console.WriteLine()
            End If
            System.Threading.Thread.Sleep(50)
        Next j
    End Sub




    Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
        Dim i As Integer
        For i = 0 To (samplesList.Count - 1) - 1
            ' Output the sample.
            OutputSample(CType(samplesList(i), CounterSample))
            OutputSample(CType(samplesList((i + 1)), CounterSample))

            ' Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())

            ' Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
        Next i
    End Sub




    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim counterValue As [Single] = s1.RawValue
        Return counterValue
    End Function 'MyComputeCounterValue


    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
        Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
        Console.WriteLine("   BaseValue        = " + s.BaseValue.ToString())
        Console.WriteLine("   CounterFrequency = " + s.CounterFrequency.ToString())
        Console.WriteLine("   CounterTimeStamp = " + s.CounterTimeStamp.ToString())
        Console.WriteLine("   CounterType      = " + s.CounterType.ToString())
        Console.WriteLine("   RawValue         = " + s.RawValue.ToString())
        Console.WriteLine("   SystemFrequency  = " + s.SystemFrequency.ToString())
        Console.WriteLine("   TimeStamp        = " + s.TimeStamp.ToString())
        Console.WriteLine("   TimeStamp100nSec = " + s.TimeStamp100nSec.ToString())
        Console.WriteLine("++++++++++++++++++++++")
    End Sub
End Class 'NumberOfItems64 


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 );
}
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class NumberOfItems64
{

	private static PerformanceCounter PC;

	public static void Main()
	{	
		ArrayList samplesList = new ArrayList();

        // If the category does not exist, create the category and exit.
        // Perfomance 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("NumberOfItems64SampleCategory") ) 
		{

			CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

			// Add the counter.
			CounterCreationData NOI64 = new 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.",
                PerformanceCounterCategoryType.SingleInstance, CCDC);
			return(true);
		}
		else
		{
			Console.WriteLine("Category exists - NumberOfItems64SampleCategory");
			return(false);
		}
	}

    private static void CreateCounters()
    {
        // Create the counters.
        PC = new PerformanceCounter("NumberOfItems64SampleCategory", 
            "NumberOfItems64Sample", 
            false);

        PC.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);

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

		}
	}

	
	//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
	//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
	private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
	{
		Single counterValue = s1.RawValue;
		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("++++++++++++++++++++++");
	}

}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class NumberOfItems64

    Private Shared PC As PerformanceCounter


    Public Shared Sub Main()
        Dim samplesList As 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 counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If

    End Sub


    Private Shared Function SetupCategory() As Boolean
        If Not PerformanceCounterCategory.Exists("NumberOfItems64SampleCategory") Then

            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim NOI64 As New 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.", _
                   PerformanceCounterCategoryType.SingleInstance, CCDC)

            Return True
        Else
            Console.WriteLine("Category exists - NumberOfItems64SampleCategory")
            Return False
        End If
    End Function 'SetupCategory


    Private Shared Sub CreateCounters()
        ' Create the counters.
        PC = New PerformanceCounter("NumberOfItems64SampleCategory", "NumberOfItems64Sample", False)

        PC.RawValue = 0
    End Sub


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

        Dim r As New Random(DateTime.Now.Millisecond)

        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99

            Dim value As Integer = r.Next(1, 10)
            Console.Write((j.ToString() + " = " + value.ToString()))

            PC.IncrementBy(value)

            If j Mod 10 = 9 Then
                OutputSample(PC.NextSample())
                samplesList.Add(PC.NextSample())
            Else
                Console.WriteLine()
            End If
            System.Threading.Thread.Sleep(50)
        Next j
    End Sub


    Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
        Dim i As Integer
        For i = 0 To (samplesList.Count - 1) - 1
            ' Output the sample.
            OutputSample(CType(samplesList(i), CounterSample))
            OutputSample(CType(samplesList((i + 1)), CounterSample))

            ' Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())

            ' Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
        Next i
    End Sub




    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim counterValue As [Single] = s1.RawValue
        Return counterValue
    End Function 'MyComputeCounterValue


    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
        Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
        Console.WriteLine(("   BaseValue        = " + s.BaseValue.ToString()))
        Console.WriteLine(("   CounterFrequency = " + s.CounterFrequency.ToString()))
        Console.WriteLine(("   CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
        Console.WriteLine(("   CounterType      = " + s.CounterType.ToString()))
        Console.WriteLine(("   RawValue         = " + s.RawValue.ToString()))
        Console.WriteLine(("   SystemFrequency  = " + s.SystemFrequency.ToString()))
        Console.WriteLine(("   TimeStamp        = " + s.TimeStamp.ToString()))
        Console.WriteLine(("   TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
        Console.WriteLine("++++++++++++++++++++++")
    End Sub
End Class 'NumberOfItems64 

SampleFraction

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

// Provides a SampleFraction counter to measure the percentage of the user processor 
// time for this process to total processor time for the process.
public class App
{

    private static PerformanceCounter perfCounter;
    private static PerformanceCounter basePerfCounter;
    private static Process thisProcess = Process.GetCurrentProcess();

    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("SampleFractionCategory"))
        {

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData sampleFraction = new CounterCreationData();
            sampleFraction.CounterType = PerformanceCounterType.SampleFraction;
            sampleFraction.CounterName = "SampleFractionSample";
            CCDC.Add(sampleFraction);

            // Add the base counter.
            CounterCreationData sampleFractionBase = new CounterCreationData();
            sampleFractionBase.CounterType = PerformanceCounterType.SampleBase;
            sampleFractionBase.CounterName = "SampleFractionSampleBase";
            CCDC.Add(sampleFractionBase);

            // Create the category.
            PerformanceCounterCategory.Create("SampleFractionCategory",
                "Demonstrates usage of the SampleFraction performance counter type.",
                PerformanceCounterCategoryType.SingleInstance, CCDC);

            return (true);
        }
        else
        {
            Console.WriteLine("Category exists - SampleFractionCategory");
            return (false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counters.

        perfCounter = new PerformanceCounter("SampleFractionCategory",
            "SampleFractionSample",
            false);


        basePerfCounter = new PerformanceCounter("SampleFractionCategory",
            "SampleFractionSampleBase",
            false);


        perfCounter.RawValue = thisProcess.UserProcessorTime.Ticks;
        basePerfCounter.RawValue = thisProcess.TotalProcessorTime.Ticks;
    }
    private static void CollectSamples(ArrayList samplesList)
    {


        // Loop for the samples.
        for (int j = 0; j < 100; j++)
        {

            perfCounter.IncrementBy(thisProcess.UserProcessorTime.Ticks);

            basePerfCounter.IncrementBy(thisProcess.TotalProcessorTime.Ticks);

            if ((j % 10) == 9)
            {
                OutputSample(perfCounter.NextSample());
                samplesList.Add(perfCounter.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 provides A percentage counter that shows the 
    // average ratio of user proccessor time to total processor time  during the last 
    // two sample intervals.
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    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 = 100 * (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("++++++++++++++++++++++");
    }
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics


' Provides a SampleFraction counter to measure the percentage of the user processor 
' time for this process to total processor time for the process.

Public Class App

    Private Shared perfCounter As PerformanceCounter
    Private Shared basePerfCounter As PerformanceCounter
    Private Shared thisProcess As Process = Process.GetCurrentProcess()


    Public Shared Sub Main()

        Dim samplesList As 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() Then
            Return
        End If
        CreateCounters()
        CollectSamples(samplesList)
        CalculateResults(samplesList)

    End Sub



    Private Shared Function SetupCategory() As Boolean
        If Not PerformanceCounterCategory.Exists("SampleFractionCategory") Then

            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim sampleFraction As New CounterCreationData()
            sampleFraction.CounterType = PerformanceCounterType.SampleFraction
            sampleFraction.CounterName = "SampleFractionSample"
            CCDC.Add(sampleFraction)

            ' Add the base counter.
            Dim sampleFractionBase As New CounterCreationData()
            sampleFractionBase.CounterType = PerformanceCounterType.SampleBase
            sampleFractionBase.CounterName = "SampleFractionSampleBase"
            CCDC.Add(sampleFractionBase)

            ' Create the category.
            PerformanceCounterCategory.Create("SampleFractionCategory", "Demonstrates usage of the SampleFraction performance counter type.", PerformanceCounterCategoryType.SingleInstance, CCDC)

            Return True
        Else
            Console.WriteLine("Category exists - SampleFractionCategory")
            Return False
        End If

    End Function 'SetupCategory


    Private Shared Sub CreateCounters()
        ' Create the counters.
        perfCounter = New PerformanceCounter("SampleFractionCategory", "SampleFractionSample", False)


        basePerfCounter = New PerformanceCounter("SampleFractionCategory", "SampleFractionSampleBase", False)


        perfCounter.RawValue = thisProcess.UserProcessorTime.Ticks
        basePerfCounter.RawValue = thisProcess.TotalProcessorTime.Ticks

    End Sub

    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)


        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99

            perfCounter.IncrementBy(thisProcess.UserProcessorTime.Ticks)

            basePerfCounter.IncrementBy(thisProcess.TotalProcessorTime.Ticks)

            If j Mod 10 = 9 Then
                OutputSample(perfCounter.NextSample())
                samplesList.Add(perfCounter.NextSample())
            Else
                Console.WriteLine()
            End If
            System.Threading.Thread.Sleep(50)
        Next j

    End Sub


    Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
        Dim i As Integer
        For i = 0 To (samplesList.Count - 1)
            ' Output the sample.
            OutputSample(CType(samplesList(i), CounterSample))
            OutputSample(CType(samplesList((i + 1)), CounterSample))

            ' Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)))

            ' Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)))
        Next i

    End Sub




    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    ' Description - This counter type provides A percentage counter that shows the 
    ' average ratio of user proccessor time to total processor time  during the last 
    ' two sample intervals.
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim numerator As [Single] = CType(s1.RawValue, [Single]) - CType(s0.RawValue, [Single])
        Dim denomenator As [Single] = CType(s1.BaseValue, [Single]) - CType(s0.BaseValue, [Single])
        Dim counterValue As [Single] = 100 * (numerator / denomenator)
        Return counterValue

    End Function 'MyComputeCounterValue


    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine(vbCr + vbLf + "+++++++++++")
        Console.WriteLine("Sample values - " + vbCr + vbLf)
        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("++++++++++++++++++++++")

    End Sub
End Class 'App

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 );
}
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class App 
{
    private static PerformanceCounter PC;

	public static void Main()
	{	
		ArrayList samplesList = new ArrayList();

        // If the category does not exist, create the category and exit.
        // Perfomance 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("RateOfCountsPerSecond32SampleCategory") ) 
        {


            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData rateOfCounts32 = new 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.",
                PerformanceCounterCategoryType.SingleInstance, CCDC); 
              return(true);
        }
        else
        {
            Console.WriteLine("Category exists - RateOfCountsPerSecond32SampleCategory");
            return(false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counter.
        PC = new PerformanceCounter("RateOfCountsPerSecond32SampleCategory", 
            "RateOfCountsPerSecond32Sample", 
            false);

        PC.RawValue=0;
        
    }

    private static void CollectSamples(ArrayList samplesList)
    {
	
        Random r = new 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(j + " = " + value);

            if ((j % 10) == 9) 
            {
                Console.WriteLine(";       NextValue() = " + PC.NextValue().ToString());
                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]) );


		}
	}


	//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
	//	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 
	//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
	private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
	{
		Single numerator = (Single)(s1.RawValue - s0.RawValue);
		Single denomenator = (Single)(s1.TimeStamp - s0.TimeStamp) / (Single)s1.SystemFrequency;
		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("++++++++++++++++++++++");
	}

}

Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class App
    Private Shared PC As PerformanceCounter


    Public Shared Sub Main()
        Dim samplesList As 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 counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If
    End Sub


    Private Shared Function SetupCategory() As Boolean

        If Not PerformanceCounterCategory.Exists("RateOfCountsPerSecond32SampleCategory") Then


            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim rateOfCounts32 As New 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.", _
                PerformanceCounterCategoryType.SingleInstance, CCDC)
            Return True
        Else
            Console.WriteLine("Category exists - RateOfCountsPerSecond32SampleCategory")
            Return False
        End If
    End Function 'SetupCategory


    Private Shared Sub CreateCounters()
        ' Create the counter.
        PC = New PerformanceCounter("RateOfCountsPerSecond32SampleCategory", "RateOfCountsPerSecond32Sample", False)

        PC.RawValue = 0
    End Sub


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

        Dim r As New Random(DateTime.Now.Millisecond)

        ' Initialize the performance counter.
        PC.NextSample()

        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99

            Dim value As Integer = r.Next(1, 10)
            PC.IncrementBy(value)
            Console.Write((j.ToString() + " = " + value.ToString()))

            If j Mod 10 = 9 Then
                Console.WriteLine((";       NextValue() = " + PC.NextValue().ToString()))
                OutputSample(PC.NextSample())
                samplesList.Add(PC.NextSample())
            Else
                Console.WriteLine()
            End If
            System.Threading.Thread.Sleep(50)
        Next j
    End Sub


    Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
        Dim i As Integer
        For i = 0 To (samplesList.Count - 1) - 1
            ' Output the sample.
            OutputSample(CType(samplesList(i), CounterSample))
            OutputSample(CType(samplesList((i + 1)), CounterSample))


            ' Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())

            ' Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
        Next i
    End Sub





    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '	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 
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim numerator As [Single] = CType(s1.RawValue - s0.RawValue, [Single])
        Dim denomenator As [Single] = CType(s1.TimeStamp - s0.TimeStamp, [Single]) / CType(s1.SystemFrequency, [Single])
        Dim counterValue As [Single] = numerator / denomenator
        Return counterValue
    End Function 'MyComputeCounterValue


    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
        Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
        Console.WriteLine(("   BaseValue        = " + s.BaseValue.ToString()))
        Console.WriteLine(("   CounterFrequency = " + s.CounterFrequency.ToString()))
        Console.WriteLine(("   CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
        Console.WriteLine(("   CounterType      = " + s.CounterType.ToString()))
        Console.WriteLine(("   RawValue         = " + s.RawValue.ToString()))
        Console.WriteLine(("   SystemFrequency  = " + s.SystemFrequency.ToString()))
        Console.WriteLine(("   TimeStamp        = " + s.TimeStamp.ToString()))
        Console.WriteLine(("   TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
        Console.WriteLine("++++++++++++++++++++++")
    End Sub
End Class 'App 

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 );
}
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class App
{
    private static PerformanceCounter PC;

    public static void Main()
    {
        ArrayList samplesList = new ArrayList();

        // If the category does not exist, create the category and exit.
        // Perfomance 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("RateOfCountsPerSecond64SampleCategory"))
        {


            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData rateOfCounts64 = new 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.",
                PerformanceCounterCategoryType.SingleInstance, CCDC);
            return (true);
        }
        else
        {
            Console.WriteLine("Category exists - RateOfCountsPerSecond64SampleCategory");
            return (false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counter.
        PC = new PerformanceCounter("RateOfCountsPerSecond64SampleCategory",
            "RateOfCountsPerSecond64Sample",
            false);

        PC.RawValue = 0;

    }

    private static void CollectSamples(ArrayList samplesList)
    {

        Random r = new 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(j + " = " + value);

            if ((j % 10) == 9)
            {
                Console.WriteLine(";       NextValue() = " + PC.NextValue().ToString());
                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]));


        }
    }

    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    //	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 
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
    {
        Single numerator = (Single)(s1.RawValue - s0.RawValue);
        Single denomenator = (Single)(s1.TimeStamp - s0.TimeStamp) / (Single)s1.SystemFrequency;
        Single counterValue = numerator / denomenator;
        return (counterValue);
    }

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

Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class App
    Private Shared PC As PerformanceCounter


    Public Shared Sub Main()
        Dim samplesList As 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 counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If
    End Sub


    Private Shared Function SetupCategory() As Boolean


        If Not PerformanceCounterCategory.Exists("RateOfCountsPerSecond64SampleCategory") Then


            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim rateOfCounts64 As New 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.", _
                PerformanceCounterCategoryType.SingleInstance, CCDC)
            Return True
        Else
            Console.WriteLine("Category exists - RateOfCountsPerSecond64SampleCategory")
            Return False
        End If
    End Function 'SetupCategory


    Private Shared Sub CreateCounters()
        ' Create the counter.
        PC = New PerformanceCounter("RateOfCountsPerSecond64SampleCategory", "RateOfCountsPerSecond64Sample", False)

        PC.RawValue = 0
    End Sub


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

        Dim r As New Random(DateTime.Now.Millisecond)

        ' Initialize the performance counter.
        PC.NextSample()

        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99

            Dim value As Integer = r.Next(1, 10)
            PC.IncrementBy(value)
            Console.Write((j.ToString() + " = " + value.ToString()))

            If j Mod 10 = 9 Then
                Console.WriteLine((";       NextValue() = " + PC.NextValue().ToString()))
                OutputSample(PC.NextSample())
                samplesList.Add(PC.NextSample())
            Else
                Console.WriteLine()
            End If
            System.Threading.Thread.Sleep(50)
        Next j
    End Sub


    Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
        Dim i As Integer
        For i = 0 To (samplesList.Count - 1) - 1
            ' Output the sample.
            OutputSample(CType(samplesList(i), CounterSample))
            OutputSample(CType(samplesList((i + 1)), CounterSample))


            ' Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " + _
            CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())

            ' Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " + _
            MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
        Next i
    End Sub




    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '	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 
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim numerator As [Single] = CType(s1.RawValue - s0.RawValue, [Single])
        Dim denomenator As [Single] = CType(s1.TimeStamp - s0.TimeStamp, [Single]) / CType(s1.SystemFrequency, [Single])
        Dim counterValue As [Single] = numerator / denomenator
        Return counterValue
    End Function 'MyComputeCounterValue


    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
        Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
        Console.WriteLine(("   BaseValue        = " + s.BaseValue.ToString()))
        Console.WriteLine(("   CounterFrequency = " + s.CounterFrequency.ToString()))
        Console.WriteLine(("   CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
        Console.WriteLine(("   CounterType      = " + s.CounterType.ToString()))
        Console.WriteLine(("   RawValue         = " + s.RawValue.ToString()))
        Console.WriteLine(("   SystemFrequency  = " + s.SystemFrequency.ToString()))
        Console.WriteLine(("   TimeStamp        = " + s.TimeStamp.ToString()))
        Console.WriteLine(("   TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
        Console.WriteLine("++++++++++++++++++++++")
    End Sub
End Class 'App

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

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 counters.
        if (SetupCategory())
            return;
        CreateCounters();
        CollectSamples(samplesList);
        CalculateResults(samplesList);
    }

    private static bool SetupCategory()
    {


        if (!PerformanceCounterCategory.Exists("RawFractionSampleCategory"))
        {


            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData rf = new CounterCreationData();
            rf.CounterType = PerformanceCounterType.RawFraction;
            rf.CounterName = "RawFractionSample";
            CCDC.Add(rf);

            // Add the base counter.
            CounterCreationData rfBase = new 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.",
                PerformanceCounterCategoryType.SingleInstance, CCDC);

            return (true);
        }
        else
        {
            Console.WriteLine("Category exists - RawFractionSampleCategory");
            return (false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counters.
        PC = new PerformanceCounter("RawFractionSampleCategory",
            "RawFractionSample",
            false);

        BPC = new PerformanceCounter("RawFractionSampleCategory",
            "RawFractionSampleBase",
            false);

        PC.RawValue = 0;
        BPC.RawValue = 0;
    }

    private static void CollectSamples(ArrayList samplesList)
    {

        Random r = new 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(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() = " + PC.NextValue().ToString());
                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; i++)
        {
            // Output the sample.
            OutputSample((CounterSample)samplesList[i]);

            // Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " +
                CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i]));

            // Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " +
                MyComputeCounterValue((CounterSample)samplesList[i]));

        }
    }

    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    // 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
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    private static Single MyComputeCounterValue(CounterSample rfSample)
    {
        Single numerator = (Single)rfSample.RawValue;
        Single denomenator = (Single)rfSample.BaseValue;
        Single counterValue = (numerator / denomenator) * 100;
        return (counterValue);
    }

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



}

Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _


Public Class App
    Private Shared PC As PerformanceCounter
    Private Shared BPC As PerformanceCounter


    Public Shared Sub Main()
        Dim samplesList As 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 counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If

    End Sub


    Private Shared Function SetupCategory() As Boolean


        If Not PerformanceCounterCategory.Exists("RawFractionSampleCategory") Then


            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim rf As New CounterCreationData()
            rf.CounterType = PerformanceCounterType.RawFraction
            rf.CounterName = "RawFractionSample"
            CCDC.Add(rf)

            ' Add the base counter.
            Dim rfBase As New 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.", _
                PerformanceCounterCategoryType.SingleInstance, CCDC)

            Return True
        Else
            Console.WriteLine("Category exists - RawFractionSampleCategory")
            Return False
        End If
    End Function 'SetupCategory


    Private Shared Sub CreateCounters()
        ' Create the counters.
        PC = New PerformanceCounter("RawFractionSampleCategory", "RawFractionSample", False)

        BPC = New PerformanceCounter("RawFractionSampleCategory", "RawFractionSampleBase", False)

        PC.RawValue = 0
        BPC.RawValue = 0
    End Sub


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

        Dim r As New Random(DateTime.Now.Millisecond)

        ' Initialize the performance counter.
        PC.NextSample()

        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99
            Dim value As Integer = r.Next(1, 10)
            Console.Write((j.ToString() + " = " + value.ToString()))

            ' 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 Then
                PC.Increment()
            End If
            ' Copy out the next value every ten times around the loop.
            If j Mod 10 = 9 Then
                Console.WriteLine((";       NextValue() = " + PC.NextValue().ToString()))
                OutputSample(PC.NextSample())
                samplesList.Add(PC.NextSample())
            Else
                Console.WriteLine()
            End If
            System.Threading.Thread.Sleep(50)
        Next j
    End Sub



    Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
        Dim i As Integer
        For i = 0 To samplesList.Count - 1
            ' Output the sample.
            OutputSample(CType(samplesList(i), CounterSample))

            ' Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample)).ToString())

            ' Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample)).ToString())
        Next i
    End Sub


    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    ' 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
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal rfSample As CounterSample) As [Single]
        Dim numerator As [Single] = CType(rfSample.RawValue, [Single])
        Dim denomenator As [Single] = CType(rfSample.BaseValue, [Single])
        Dim counterValue As [Single] = numerator / denomenator * 100
        Return counterValue
    End Function 'MyComputeCounterValue


    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine("+++++++++++")
        Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
        Console.WriteLine(("   BaseValue        = " + s.BaseValue.ToString()))
        Console.WriteLine(("   CounterFrequency = " + s.CounterFrequency.ToString()))
        Console.WriteLine(("   CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
        Console.WriteLine(("   CounterType      = " + s.CounterType.ToString()))
        Console.WriteLine(("   RawValue         = " + s.RawValue.ToString()))
        Console.WriteLine(("   SystemFrequency  = " + s.SystemFrequency.ToString()))
        Console.WriteLine(("   TimeStamp        = " + s.TimeStamp.ToString()))
        Console.WriteLine(("   TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
        Console.WriteLine("++++++++++++++++++++++")
    End Sub
End Class 'App 



Commenti

Alcuni tipi di contatori rappresentano dati non elaborati, mentre altri rappresentano valori calcolati basati su uno o più campioni di contatori.Some counter types represent raw data, while others represent calculated values that are based on one or more counter samples. Le categorie seguenti classificano i tipi di contatori disponibili.The following categories classify the types of counters available.

  • Media: Misura un valore nel tempo e visualizza la media delle ultime due misure.Average: Measures a value over time and displays the average of the last two measurements. Associato a ogni contatore medio è un contatore di base che tiene traccia del numero di campioni necessari.Associated with each average counter is a base counter that tracks the number of samples involved.

  • Differenza: Sottrae l'ultima misura rispetto a quella precedente e visualizza la differenza, se è positiva; Se negativo, viene visualizzato uno zero.Difference: Subtracts the last measurement from the previous one and displays the difference, if it is positive; if negative, it displays a zero.

  • Istantanea: Visualizza la misurazione più recente.Instantaneous: Displays the most recent measurement.

  • Percentuale: Visualizza i valori calcolati come percentuale.Percentage: Displays calculated values as a percentage.

  • Frequenza: Esegue il campionamento di un numero crescente di eventi nel tempo e divide la modifica nei valori di conteggio in base alla modifica nel tempo per visualizzare una frequenza di attività.Rate: Samples an increasing count of events over time and divides the change in count values by the change in time to display a rate of activity.

Quando si campionano i dati dei contatori delle prestazioni, l'utilizzo di un tipo di contatore che rappresenta una media può rendere significativi i valori dei dati non elaborati.When sampling performance counter data, using a counter type that represents an average can make raw data values meaningful for your use. Il contatore NumberOfItems64 dati non elaborati, ad esempio, può esporre dati abbastanza casuali da esempio ad esempio.For example, the raw data counter NumberOfItems64 can expose data that is fairly random from sample to sample. La formula per un calcolo medio dei valori restituiti dal contatore è (X 0 + X 1 +... + X n)/n, dove ogni X i è un campione di contatore non elaborato.The formula for an average calculation of the values that the counter returns would be (X 0 +X 1 +…+X n)/n, where each X i is a raw counter sample.

I contatori di velocità sono simili ai contatori medi, ma sono più utili per le situazioni in cui la frequenza aumenta quando si usa una risorsa.Rate counters are similar to average counters, but more useful for situations in which the rate increases as a resource is used. Una formula che calcola rapidamente la media è ((X n-X 0)/(T n-T 0))/Frequency, dove ogni X i è un campione di contatore e ogni T i è l'ora in cui è stato effettuato il campione corrispondente.A formula that quickly calculates the average is ((X n -X 0)/(T n -T 0)) / frequency, where each X i is a counter sample and each T i is the time that the corresponding sample was taken. Il risultato è l'utilizzo medio al secondo.The result is the average usage per second.

I contatori multitimer raccolgono i dati da più di un'istanza di un componente, ad esempio un processore o un disco.Multitimer counters collect data from more than one instance of a component, such as a processor or disk.

I contatori inversi misurano il tempo in cui un componente non è attivo e derivano il tempo attivo dalla misurazione.Inverse counters measure the time that a component is not active and derive the active time from that measurement.

Nota

Se non diversamente specificato, la base temporale è di secondi.Unless otherwise indicated, the time base is seconds.

Quando si instrumentano le applicazioni (creando e scrivendo contatori di prestazioni personalizzati), è possibile che si stiano utilizzando tipi di contatori delle prestazioni basati su un contatore di base associato utilizzato nei calcoli.When instrumenting applications (creating and writing custom performance counters), you might be working with performance counter types that rely on an accompanying base counter that is used in the calculations. Il contatore di base deve trovarsi immediatamente dopo il contatore associato CounterCreationDataCollection nella raccolta usata dall'applicazione.The base counter must be immediately after its associated counter in the CounterCreationDataCollection collection your application uses. Nella tabella seguente sono elencati i tipi di contatore di base con i corrispondenti tipi di contatori delle prestazioni.The following table lists the base counter types with their corresponding performance counter types.

Tipo di contatore di baseBase counter type Tipi di contatori delle prestazioniPerformance counter types
AverageBase AverageTimer32

AverageCount64
CounterMultiBase CounterMultiTimer

CounterMultiTimerInverse

CounterMultiTimer100Ns

CounterMultiTimer100NsInverse
RawBase RawFraction
SampleBase SampleFraction

Di seguito sono riportate le formule utilizzate da alcuni contatori che rappresentano valori calcolati:The following are the formulas used by some of the counters that represent calculated values:

  • AverageCount64: (N1-N0)/(B1-B0), dove n 1 e n 0 sono le letture del contatore delle prestazioni e B1 e B0 sono i AverageBase valori corrispondenti.AverageCount64: (N1 - N0)/(B1 - B0), where N 1 and N 0 are performance counter readings, and B1 and B0 are their corresponding AverageBase values. Il numeratore rappresenta quindi il numero di elementi elaborati durante l'intervallo di campionamento e il denominatore rappresenta il numero di operazioni completate durante l'intervallo di campionamento.Thus, the numerator represents the numbers of items processed during the sample interval, and the denominator represents the number of operations completed during the sample interval.

  • AverageTimer32: ((N1-N0)/f)/(B1-B0), dove N1 e N0 sono letture del contatore delle prestazioni, B1 e B0 sono i AverageBase valori corrispondenti e F è il numero di cicli al secondo.AverageTimer32: ((N1 - N0)/F)/(B1 - B0), where N1 and N0 are performance counter readings, B1 and B0 are their corresponding AverageBase values, and F is the number of ticks per second. Il valore di F viene fattorizzato nell'equazione, in modo che il risultato possa essere visualizzato in pochi secondi.The value of F is factored into the equation so that the result can be displayed in seconds. Il numeratore rappresenta quindi il numero di cicli conteggiati durante l'ultimo intervallo di campionamento, F rappresenta la frequenza dei cicli e il denominatore rappresenta il numero di operazioni completate durante l'ultimo intervallo di campionamento.Thus, the numerator represents the numbers of ticks counted during the last sample interval, F represents the frequency of the ticks, and the denominator represents the number of operations completed during the last sample interval.

  • CounterDelta32: N1-N0, dove N1 e N0 sono letture del contatore delle prestazioni.CounterDelta32: N1 - N0, where N1 and N0 are performance counter readings.

  • CounterDelta64: N1-N0, dove N1 e N0 sono letture del contatore delle prestazioni.CounterDelta64: N1 - N0, where N1 and N0 are performance counter readings.

  • CounterMultiTimer: ((N1-N0)/(D1-D0)) x 100/B, dove N1 e N0 sono letture del contatore delle prestazioni, D1 e D0 sono le letture temporali corrispondenti nei cicli del timer delle prestazioni di sistema e la variabile B indica il numero di base per i componenti monitorati (usando un contatore di base di Ty PE CounterMultiBase).CounterMultiTimer: ((N1 - N0) / (D1 - D0)) x 100 / B, where N1 and N0 are performance counter readings, D1 and D0 are their corresponding time readings in ticks of the system performance timer, and the variable B denotes the base count for the monitored components (using a base counter of type CounterMultiBase). Il numeratore rappresenta quindi le parti dell'intervallo di campionamento durante le quali i componenti monitorati erano attivi e il denominatore rappresenta il tempo totale trascorso dell'intervallo di campionamento.Thus, the numerator represents the portions of the sample interval during which the monitored components were active, and the denominator represents the total elapsed time of the sample interval.

  • CounterMultiTimer100Ns: ((N1-N0)/(D1-D0)) x 100/B, dove N1 e N0 sono letture del contatore delle prestazioni, D1 e D0 sono le letture temporali corrispondenti in unità 100-nanosecondi e la variabile B indica il numero di base per i componenti monitorati (usando un contatore di base di tipo CounterMultiBase).CounterMultiTimer100Ns: ((N1 - N0) / (D1 - D0)) x 100 / B, where N1 and N0 are performance counter readings, D1 and D0 are their corresponding time readings in 100-nanosecond units, and the variable B denotes the base count for the monitored components (using a base counter of type CounterMultiBase). Il numeratore rappresenta quindi le parti dell'intervallo di campionamento durante le quali i componenti monitorati erano attivi e il denominatore rappresenta il tempo totale trascorso dell'intervallo di campionamento.Thus, the numerator represents the portions of the sample interval during which the monitored components were active, and the denominator represents the total elapsed time of the sample interval.

  • CounterMultiTimer100NsInverse: (B-((N1-N0)/(D1-D0))) x 100, dove il denominatore rappresenta il tempo totale trascorso dell'intervallo di campionamento, il numeratore rappresenta l'intervallo di tempo durante il quale i componenti monitorati erano inattivi e B rappresenta il numero di componenti monitorati , usando un contatore di base di CounterMultiBasetipo.CounterMultiTimer100NsInverse: (B - ((N1 - N0) / (D1 - D0))) x 100, where the denominator represents the total elapsed time of the sample interval, the numerator represents the time during the interval when monitored components were inactive, and B represents the number of components being monitored, using a base counter of type CounterMultiBase.

  • CounterMultiTimerInverse: (B-((N1-N0)/(D1-D0))) x 100, dove il denominatore rappresenta il tempo totale trascorso dell'intervallo di campionamento, il numeratore rappresenta l'intervallo di tempo durante il quale i componenti monitorati erano inattivi e B rappresenta il numero di componenti monitorati , usando un contatore di base di CounterMultiBasetipo.CounterMultiTimerInverse: (B- ((N1 - N0) / (D1 - D0))) x 100, where the denominator represents the total elapsed time of the sample interval, the numerator represents the time during the interval when monitored components were inactive, and B represents the number of components being monitored, using a base counter of type CounterMultiBase.

  • CounterTimer: (N1-N0)/(D1-D0), dove N1 e N0 sono letture del contatore delle prestazioni e D1 e D0 sono le letture temporali corrispondenti.CounterTimer: (N1 - N0) / (D1 - D0), where N1 and N0 are performance counter readings, and D1 and D0 are their corresponding time readings. Il numeratore rappresenta quindi le parti dell'intervallo di campionamento durante le quali i componenti monitorati erano attivi e il denominatore rappresenta il tempo totale trascorso dell'intervallo di campionamento.Thus, the numerator represents the portions of the sample interval during which the monitored components were active, and the denominator represents the total elapsed time of the sample interval.

  • CounterTimerInverse: (1-((N1-N0)/(D1-D0))) x 100, dove il numeratore rappresenta l'intervallo di tempo durante il quale i componenti monitorati erano inattivi e il denominatore rappresenta il tempo totale trascorso dell'intervallo di campionamento.CounterTimerInverse: (1- ((N1 - N0) / (D1 - D0))) x 100, where the numerator represents the time during the interval when the monitored components were inactive, and the denominator represents the total elapsed time of the sample interval.

  • CountPerTimeInterval32: (N1-N0)/(D1-D0), dove il numeratore rappresenta il numero di elementi nella coda e il denominatore rappresenta il tempo trascorso durante l'ultimo intervallo di campionamento.CountPerTimeInterval32: (N1 - N0) / (D1 - D0), where the numerator represents the number of items in the queue, and the denominator represents the time elapsed during the last sample interval.

  • CountPerTimeInterval64: (N1-N0)/(D1-D0), dove il numeratore rappresenta il numero di elementi in una coda e il denominatore rappresenta il tempo trascorso durante l'intervallo di campionamento.CountPerTimeInterval64: (N1 - N0) / (D1 - D0), where the numerator represents the number of items in a queue and the denominator represents the time elapsed during the sample interval.

  • ElapsedTime: (D0-N0)/F, dove D0 rappresenta l'ora corrente, N0 rappresenta l'ora in cui l'oggetto è stato avviato e F rappresenta il numero di unità di tempo che intercorrono tra un secondo.ElapsedTime: (D0 - N0) / F, where D0 represents the current time, N0 represents the time the object was started, and F represents the number of time units that elapse in one second. Il valore di F viene fattorizzato nell'equazione, in modo che il risultato possa essere visualizzato in pochi secondi.The value of F is factored into the equation so that the result can be displayed in seconds.

  • NumberOfItems32: No.NumberOfItems32: None. Non visualizza una media, ma Visualizza i dati non elaborati raccolti.Does not display an average, but shows the raw data as it is collected.

  • NumberOfItems64: No.NumberOfItems64: None. Non visualizza una media, ma Visualizza i dati non elaborati raccolti.Does not display an average, but shows the raw data as it is collected.

  • NumberOfItemsHEX32: No.NumberOfItemsHEX32: None. Non visualizza una media, ma Visualizza i dati non elaborati raccolti.Does not display an average, but shows the raw data as it is collected.

  • NumberOfItemsHEX64: No.NumberOfItemsHEX64: None. Non visualizza una media, ma mostra i dati non elaborati raccoltiDoes not display an average, but shows the raw data as it is collected

  • RateOfCountsPerSecond32: (N1-N0)/((D1-D0)/F), dove N1 e N0 sono letture del contatore delle prestazioni, D1 e D0 sono le letture temporali corrispondenti e F rappresenta il numero di cicli al secondo.RateOfCountsPerSecond32: (N1 - N0) / ((D1 - D0) / F), where N1 and N0 are performance counter readings, D1 and D0 are their corresponding time readings, and F represents the number of ticks per second. Il numeratore rappresenta quindi il numero di operazioni eseguite durante l'ultimo intervallo di campionamento, il denominatore rappresenta il numero di cicli trascorsi durante l'ultimo intervallo di campionamento e F è la frequenza dei cicli.Thus, the numerator represents the number of operations performed during the last sample interval, the denominator represents the number of ticks elapsed during the last sample interval, and F is the frequency of the ticks. Il valore di F viene fattorizzato nell'equazione, in modo che il risultato possa essere visualizzato in pochi secondi.The value of F is factored into the equation so that the result can be displayed in seconds.

  • RateOfCountsPerSecond64: (N1-N0)/((D1-D0)/F), dove N1 e N0 sono letture del contatore delle prestazioni, D1 e D0 sono le letture temporali corrispondenti e F rappresenta il numero di cicli al secondo.RateOfCountsPerSecond64: (N1 - N0) / ((D1 - D0) / F), where N1 and N0 are performance counter readings, D1 and D0 are their corresponding time readings, and F represents the number of ticks per second. Il numeratore rappresenta quindi il numero di operazioni eseguite durante l'ultimo intervallo di campionamento, il denominatore rappresenta il numero di cicli trascorsi durante l'ultimo intervallo di campionamento e F è la frequenza dei cicli.Thus, the numerator represents the number of operations performed during the last sample interval, the denominator represents the number of ticks elapsed during the last sample interval, and F is the frequency of the ticks. Il valore di F viene fattorizzato nell'equazione, in modo che il risultato possa essere visualizzato in pochi secondi.The value of F is factored into the equation so that the result can be displayed in seconds.

  • RawFraction: (N0/D0) x 100, dove D0 rappresenta un attributo misurato (usando un contatore di base RawBasedi tipo) e N0 rappresenta un componente di tale attributo.RawFraction: (N0 / D0) x 100, where D0 represents a measured attribute (using a base counter of type RawBase) and N0 represents one component of that attribute.

  • SampleCounter: (N1-N0)/((D1-D0)/F), dove il numeratore (N) rappresenta il numero di operazioni completate, il denominatore (D) rappresenta il tempo trascorso in unità di cicli del timer delle prestazioni di sistema e F rappresenta il numero di cicli che intercorrono tra un secondo.SampleCounter: (N1 - N0) / ((D1 - D0) / F), where the numerator (N) represents the number of operations completed, the denominator (D) represents elapsed time in units of ticks of the system performance timer, and F represents the number of ticks that elapse in one second. F viene fattorizzato nell'equazione, in modo che il risultato possa essere visualizzato in pochi secondi.F is factored into the equation so that the result can be displayed in seconds.

  • SampleFraction: ((N1-N0)/(D1-D0)) x 100, dove il numeratore rappresenta il numero di operazioni completate durante l'ultimo intervallo di campionamento e il denominatore rappresenta la modifica del numero di tutte le operazioni (del tipo misurato) completate durante l'intervallo di campionamento, utilizzando i contatori di SampleBasetipo.SampleFraction: ((N1 - N0) / (D1 - D0)) x 100, where the numerator represents the number of successful operations during the last sample interval, and the denominator represents the change in the number of all operations (of the type measured) completed during the sample interval, using counters of type SampleBase.

  • Timer100Ns: (N1-N0)/(D1-D0) x 100, dove il numeratore rappresenta le parti dell'intervallo di campionamento durante le quali i componenti monitorati erano attivi e il denominatore rappresenta il tempo totale trascorso dell'intervallo di campionamento.Timer100Ns: (N1 - N0) / (D1 - D0) x 100, where the numerator represents the portions of the sample interval during which the monitored components were active, and the denominator represents the total elapsed time of the sample interval.

  • Timer100NsInverse: (1-((N1-N0)/(D1-D0))) x 100, dove il numeratore rappresenta l'intervallo di tempo durante il quale i componenti monitorati erano inattivi e il denominatore rappresenta il tempo totale trascorso dell'intervallo di campionamento.Timer100NsInverse: (1- ((N1 - N0) / (D1 - D0))) x 100, where the numerator represents the time during the interval when the monitored components were inactive, and the denominator represents the total elapsed time of the sample interval.

Si applica a

Vedi anche