This documentation is archived and is not being maintained.

CounterSample Structure

Defines a structure that holds the raw data for a performance counter.

Namespace:  System.Diagnostics
Assembly:  System (in System.dll)

public value class CounterSample

The CounterSample type exposes the following members.

Public methodCounterSample(Int64, Int64, Int64, Int64, Int64, Int64, PerformanceCounterType)Initializes a new instance of the CounterSample structure and sets the CounterTimeStamp property to 0 (zero).
Public methodCounterSample(Int64, Int64, Int64, Int64, Int64, Int64, PerformanceCounterType, Int64)Initializes a new instance of the CounterSample structure and sets the CounterTimeStamp property to the value that is passed in.

Public propertyBaseValueGets an optional, base raw value for the counter.
Public propertyCounterFrequencyGets the raw counter frequency.
Public propertyCounterTimeStampGets the counter's time stamp.
Public propertyCounterTypeGets the performance counter type.
Public propertyRawValueGets the raw value of the counter.
Public propertySystemFrequencyGets the raw system frequency.
Public propertyTimeStampGets the raw time stamp.
Public propertyTimeStamp100nSecGets the raw, high-fidelity time stamp.

Public methodStatic memberCalculate(CounterSample)Calculates the performance data of the counter, using a single sample point. This method is generally used for uncalculated performance counter types.
Public methodStatic memberCalculate(CounterSample, CounterSample)Calculates the performance data of the counter, using two sample points. This method is generally used for calculated performance counter types, such as averages.
Public methodEquals(CounterSample)Indicates whether the specified CounterSample structure is equal to the current CounterSample structure.
Public methodEquals(Object)Indicates whether the specified structure is a CounterSample structure and is identical to the current CounterSample structure. (Overrides ValueType::Equals(Object).)
Protected methodFinalizeAllows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.)
Public methodGetHashCodeGets a hash code for the current counter sample. (Overrides ValueType::GetHashCode().)
Public methodGetTypeGets the Type of the current instance. (Inherited from Object.)
Protected methodMemberwiseCloneCreates a shallow copy of the current Object. (Inherited from Object.)
Public methodToStringReturns the fully qualified type name of this instance. (Inherited from ValueType.)

Public operatorStatic memberEqualityReturns a value that indicates whether two CounterSample structures are equal.
Public operatorStatic memberInequalityReturns a value that indicates whether two CounterSample structures are not equal.

Public fieldStatic memberEmptyDefines an empty, uninitialized performance counter sample of type NumberOfItems32.

The following example demonstrates the use of the CounterSample class to display data for a performance counter.

#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);
      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 );
      if ( (j % 10) == 9 )
         OutputSample( PC->NextSample() );
         samplesList->Add( PC->NextSample() );
      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;
   CreateCounters( PC, BPC );
   CollectSamples( samplesList, PC, BPC );
   CalculateResults( samplesList );

.NET Framework

Supported in: 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Windows 7, Windows Vista SP1 or later, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (Server Core not supported), Windows Server 2008 R2 (Server Core supported with SP1 or later), Windows Server 2003 SP2

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.