PerformanceCounterType 列挙体とは？ わかりやすく解説

Weblio 辞書 > コンピュータ > .NET Framework クラス ライブラリ リファレンス > PerformanceCounterType 列挙体の意味・解説 
.NET Framework クラス ライブラリ リファレンス
索引トップ 用語の索引 ランキング
日本マイクロソフト株式会社日本マイクロソフト株式会社

PerformanceCounterType 列挙体

PerformanceCounter インスタンスの NextValue メソッドを計算するために使用する数式を指定します。

名前空間: System.Diagnostics
アセンブリ: System (system.dll 内)
構文構文

Visual Basic (宣言)
Public Enumeration PerformanceCounterType
Visual Basic (使用法)
Dim instance As PerformanceCounterType
C#
public enum PerformanceCounterType
C++
public enum class PerformanceCounterType
J#
public enum PerformanceCounterType
JScript
public enum PerformanceCounterType
メンバメンバ
 メンバ名説明
AverageBaseAverageTimer32 や AverageCount64 など、時間または回数の平均を計算するために使用されるベース カウンタ。"操作ごとの時間" または "操作ごとの回数" を表すカウンタの計算に使用する分母を格納します。 
AverageCount64処理された項目の数を操作中の平均で示す平均カウンタ。このタイプのカウンタは、完了した処理数に対する処理された項目の比率を表示します。比率は、最後の間隔で処理された項目数と、最後の間隔で完了した操作の数を比較することによって計算されます。 

数式 : (N 1 -N 0)/(B 1 -B 0) で計算されます。ここで、N 1 および N 0 はパフォーマンス カウンタの読み取りを表し、B 1 と B 0 はそれぞれに対応する AverageBase 値を表します。つまり、分子はサンプル間隔中に処理された項目数を表し、分母はサンプル間隔中に完了した操作の数を表します。

このタイプのカウンタには、PhysicalDisk\ Avg.Disk Bytes/Transfer などがあります。

AverageTimer32処理または操作を完了するまでに経過した時間の平均を計測する平均カウンタ。このタイプのカウンタは、サンプル間隔で完了した処理または操作に対する、その間隔での経過時間の合計の比率を表示します。このカウンタ タイプは、システム時計のタイマ刻みで時間を計測します。 

数式 : ((N 1 -N 0)/F)/(B 1 -B 0) で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取り、B 1 と B 0 はそれぞれに対応する AverageBase 値、F は 1 秒あたりのタイマ刻み数を表します。F の値が数式で考慮されるため、結果は秒単位で表示されます。つまり、分子は最後のサンプル間隔中にカウントされたタイマ刻み数を表し、F はタイマ刻みの頻度を表し、分母は最後のサンプル間隔中に完了した操作の数を表します。

このタイプのカウンタには、PhysicalDisk\ Avg.Disk sec/Transfer などがあります。

CounterDelta322 つの最新のサンプル間隔を使用して、その間の計測対象の属性の変化を示す差カウンタ。 

数式 : N 1 -N 0 で計算されます。ここで、N 1 および N 0 はパフォーマンス カウンタの読み取りを表します。

CounterDelta642 つの最新のサンプル間隔を使用して、その間の計測対象の属性の変化を示す差カウンタ。CounterDelta32 カウンタ タイプと同じですが、大きな値を処理できるように、大きなフィールドを使用します。 

数式 : N 1 -N 0 で計算されます。ここで、N 1 および N 0 はパフォーマンス カウンタの読み取りを表します。

CounterMultiBaseサンプリングする項目の数を示すベース カウンタ。複数の似た項目について、タイミングをとりながらサンプリングされた項目の平均を取得する計算で、分母として使用されます。CounterMultiTimer、CounterMultiTimerInverse、CounterMultiTimer100Ns、および CounterMultiTimer100NsInverse で使用します。 
CounterMultiTimer1 つ以上のコンポーネントのアクティブな時間をサンプル間隔の合計時間に対するパーセントで表示するパーセント カウンタ。分子は、同時に運用されるコンポーネントのアクティブな時間を記録するため、結果のパーセントは 100 パーセントを超えることがあります。 

このカウンタはマルチタイマです。マルチタイマは、プロセッサやディスクなど、コンポーネントの複数のインスタンスからデータを収集します。このカウンタ タイプは、システム パフォーマンス タイマのタイマ刻みの単位で時間を計測するという点で、100 ナノ秒単位で計測する CounterMultiTimer100Ns と異なります。

数式 : ((N 1 - N 0) / (D 1 - D 0)) × 100 / B で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取り、D 1 と D 0 はそれぞれに対応する時刻の読み取り (システム パフォーマンス タイマのタイマ刻み単位) を表し、変数 B は監視対象コンポーネントのベース カウンタ (カウンタ タイプが CounterMultiBase のベース カウンタを使用) を表します。つまり、分子は、監視するコンポーネントがアクティブだったサンプル間隔の一部分を表し、分母は、サンプル間隔の経過時間の合計を表します。

CounterMultiTimer100Ns1 つ以上のコンポーネントのアクティブな時間をサンプル間隔の合計時間に対するパーセントで示すパーセント カウンタ。時間を 100 ナノ秒 (ns) 単位で計測します。 

このカウンタ タイプはマルチタイマです。マルチタイマは、プロセッサやディスクなど、コンポーネントの複数のインスタンスを監視するようにデザインされています。

数式 : ((N 1 - N 0) / (D 1 - D 0)) × 100 / B で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取り、D 1 と D 0 はそれぞれに対応する時刻の読み取り (100 ナノ秒単位) を表し、変数 B は監視対象コンポーネントのベース カウンタ (カウンタ タイプが CounterMultiBase のベース カウンタを使用) を表します。つまり、分子は、監視するコンポーネントがアクティブだったサンプル間隔の一部分を表し、分母は、サンプル間隔の経過時間の合計を表します。

CounterMultiTimer100NsInverse1 つ以上のコンポーネントのアクティブな時間をサンプル間隔の合計時間に対するパーセントで示すパーセント カウンタ。このカウンタ タイプは、時間を 100 ナノ秒 (ns) 単位で計測します。コンポーネントがアクティブでなかった時間を計測し、監視するオブジェクト数かける 100 パーセントから計測値を減算することによってアクティブな時間を導出します。 

このカウンタ タイプは逆マルチタイマです。マルチタイマは、プロセッサやディスクなど、コンポーネントの複数のインスタンスを監視するようにデザインされています。逆カウンタは、コンポーネントがアクティブでない時間を計測し、アクティブでない時間の計測値からアクティブな時間を導出します。

数式 : (B - ((N 1 - N 0) / (D 1 - D 0))) × 100 で計算されます。ここで、分母はサンプル間隔の経過時間合計を表し、分子はその間隔で監視対象コンポーネントがアクティブでなかった時間を表し、B はカウンタ タイプが CounterMultiBase のベース カウンタを使用して監視するコンポーネントの数を表します。

CounterMultiTimerInverse1 つ以上のコンポーネントのアクティブな時間をサンプル間隔の合計時間に対するパーセントで示すパーセント カウンタ。コンポーネントがアクティブでなかった時間を計測し、監視するオブジェクト数かける 100 パーセントから計測値を減算することによってアクティブな時間を導出します。 

このカウンタ タイプは逆マルチタイマです。マルチタイマは、プロセッサやディスクなど、コンポーネントの複数のインスタンスを監視します。逆カウンタは、コンポーネントがアクティブでない時間を計測し、この計測値からアクティブな時間を導出します。

このカウンタは、システム パフォーマンス タイマのタイマ刻みの単位で時間を計測するという点で、100 ナノ秒単位で計測する CounterMultiTimer100NsInverse と異なります。

数式 : (B - ((N 1 - N 0) / (D 1 - D 0))) × 100 で計算されます。ここで、分母はサンプル間隔の経過時間合計を表し、分子はその間隔で監視対象コンポーネントがアクティブでなかった時間を表し、B はカウンタ タイプが CounterMultiBase のベース カウンタを使用して監視するコンポーネントの数を表します。

CounterTimerコンポーネントがアクティブだった平均時間をサンプル時間合計に対するパーセントで示すパーセント カウンタ。 

数式 : (N 1 - N 0) / (D 1 - D 0) で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取りを表し、D 1 と D 0 はそれぞれに対応する時刻の読み取りを表します。つまり、分子は、監視するコンポーネントがアクティブだったサンプル間隔の一部分を表し、分母は、サンプル間隔の経過時間の合計を表します。

CounterTimerInverseサンプル間隔中に記録されたアクティブな時間の平均パーセントを表示するパーセント カウンタ。このカウンタの値は、サービスがアクティブでなかった時間のパーセントを監視し、この値を 100 パーセントから減算することによって計算されます。 

逆カウンタ タイプです。逆カウンタは、コンポーネントがアクティブでない時間を計測し、この計測値からアクティブな時間を導出します。このカウンタ タイプは CounterTimer100NsInv と同じですが、100 ナノ秒単位ではなく、システム パフォーマンス タイマのタイマ刻みの単位で時間を計測するという点が異なります。

数式 : (1- ((N 1 - N 0) / (D 1 - D 0))) × 100 で計算されます。ここで、分子はその間隔で監視対象コンポーネントがアクティブでなかった時間を表し、分母はサンプル間隔の経過時間合計を表します。

CountPerTimeInterval32一定時間の間のリソースに対するキューの長さの平均を監視するようにデザインされた平均カウンタ。間隔の存続期間で分割された最後の 2 つのサンプル間隔の間で監視されたキューの長さの差を示します。このカウンタ タイプは、通常、キューに置かれた項目または待機中の項目の数を追跡するために使用されます。 

数式 : (N 1 - N 0) / (D 1 - D 0) で計算されます。ここで、分子はキューの項目数を表し、分母は最後のサンプル間隔の経過時間を表します。

CountPerTimeInterval64一定時間の間のリソースに対するキューの長さの平均を監視する平均カウンタ。このカウンタ タイプは、間隔の存続期間で分割された最後の 2 つのサンプル間隔の間で監視されたキューの長さの差を示します。このカウンタ タイプは、CountPerTimeInterval32 と同じですが、大きな値を処理できるように、大きなフィールドを使用します。このカウンタ タイプは、通常、キューに置かれたまたは待機中の大量または多数の項目の数を追跡するために使用されます。 

数式 : (N 1 - N 0) / (D 1 - D 0) で計算されます。ここで、分子はキューの項目数を表し、分母はサンプル間隔の経過時間を表します。

ElapsedTimeコンポーネントまたはプロセスが開始された時間と、この値が計算された時間の間の合計時間を示す差タイマ。 

数式 : (D 0 - N 0) / F で計算されます。ここで、D 0 は現在時刻を表し、N 0 はオブジェクトが開始された時刻を表し、F は 1 秒間に経過する時間単位数を表します。F の値が数式で考慮されるため、結果は秒単位で表示されます。

このタイプのカウンタには、System\ System Up Time などがあります。

NumberOfItems32最新の記録値を示す即時カウンタ。項目または操作の単純なカウントを保持するときなどに使用します。 

数式 : なし。平均は表示されませんが、収集した生データが表示されます。

このタイプのカウンタには、Memory\Available Bytes などがあります。

NumberOfItems64最新の記録値を示す即時カウンタ。大量の項目または操作の単純なカウントを保持するときなどに使用します。NumberOfItems32 と同じですが、大きな値を処理できるように、大きなフィールドを使用します。 

数式 : なし。平均は表示されませんが、収集した生データが表示されます。

NumberOfItemsHEX32最新の記録値を 16 進形式で示す即時カウンタ。項目または操作の単純なカウントを保持するときなどに使用します。 

数式 : なし。平均は表示されませんが、収集した生データが表示されます。

NumberOfItemsHEX64最新の記録値を示す即時カウンタ。大量の項目または操作の単純なカウントを保持するときなどに使用します。NumberOfItemsHEX32 と同じですが、大きな値を処理できるように、大きなフィールドを使用します。 

数式 : なし。平均は表示されませんが、収集した生データが表示されます。

RateOfCountsPerSecond32サンプル間隔の各秒で完了した平均操作数を示す差カウンタ。このタイプのカウンタは、システム時計のタイマ刻みで時間を計測します。 

数式 : (N 1 - N 0) / ((D 1 -D 0) / F) で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取り、D 1 と D 0 はそれぞれに対応する時刻の読み取り、F は 1 秒あたりのタイマ刻み数を表します。つまり、分子は最後のサンプル間隔中に実行された操作の数を表し、分母は最後のサンプル間隔中に経過したタイマ刻み数を表し、F はタイマ刻みの頻度を表します。F の値が数式で考慮されるため、結果は秒単位で表示されます。

このタイプのカウンタには、System\ File Read Operations/sec などがあります。

RateOfCountsPerSecond64サンプル間隔の各秒で完了した平均操作数を示す差カウンタ。このタイプのカウンタは、システム時計のタイマ刻みで時間を計測します。このカウンタ タイプは RateOfCountsPerSecond32 タイプと同じですが、バイト転送速度など 1 秒ごとに大量の項目数または操作数を追跡するために、大きな値を処理できるように、大きなフィールドを使用します。 

数式 : (N 1 - N 0) / ((D 1 -D 0) / F) で計算されます。ここで、N 1 と N 0 はパフォーマンス カウンタの読み取り、D 1 と D 0 はそれぞれに対応する時刻の読み取り、F は 1 秒あたりのタイマ刻み数を表します。つまり、分子は最後のサンプル間隔中に実行された操作の数を表し、分母は最後のサンプル間隔中に経過したタイマ刻み数を表し、F はタイマ刻みの頻度を表します。F の値が数式で考慮されるため、結果は秒単位で表示されます。

このタイプのカウンタには、System\ File Read Bytes/sec などがあります。

RawBase通常の算術的な分数を表すカウンタの分母を格納するベース カウンタ。RawFraction 値の計算で分母として使用する前に、この値がゼロを超えることを確認してください。 
RawFractionセットに対するサブセットの比率をパーセントで示す即時パーセント カウンタ。たとえば、ディスクで使用中のバイト数とディスクの総バイト数を比較します。このタイプのカウンタは、一定期間の平均ではなく、現在のパーセントだけを表示します。 

数式 : (N 0 / D 0) × 100 で計算されます。ここで、D 0 は計測対象の属性 (カウンタ タイプが RawBase のベース カウンタを使用) を表し、N 0 は、その属性の 1 つのコンポーネントを表します。

このタイプのカウンタには、Paging File\% Usage Peak などがあります。

SampleBase取得したサンプリング割り込みの回数を格納するベース カウンタ。サンプリング分数の分母として使用されます。サンプリング分数は、サンプリング割り込みに対して 1 (または true) だったサンプルの数です。SampleCounter または SampleFraction の計算で分母として使用する前に、この値が 0 より大きいことを確認してください。 
SampleCounter1 秒間に完了した平均操作数を示す平均カウンタ。このタイプのカウンタがデータをサンプリングすると、各サンプリング割り込みが 1 または 0 を返します。カウンタ データは、サンプリングされたデータの数です。システム パフォーマンス タイマのタイマ刻みの時間単位を計測します。 

数式 : (N 1 – N 0) / ((D 1 – D 0) / F)。ここで、分子 (N) は実行される操作の数を表し、分母 (D) はシステム パフォーマンス タイマのタイマ刻み単位で示した経過時間を表し、F は 1 秒間のタイマ刻み数を表します。F が数式で考慮されるため、結果は秒単位で表示されます。

SampleFraction最後の 2 つのサンプル間隔中に発生したすべての操作に対するヒット カウントの平均比率を示すパーセント カウンタ。 

数式 : ((N 1 - N 0) / (D 1 - D 0)) × 100 で計算されます。ここで、分子は最後のサンプル間隔で成功した操作の数を表し、分母は、カウンタ タイプが SampleBase のカウンタを使用して、サンプル間隔で完了したすべての操作 (計測対象のタイプの操作) の数の変化を表します。

このタイプのカウンタには、Cache\Pin Read Hits % などがあります。

Timer100Nsコンポーネントのアクティブな時間をサンプル間隔の合計経過時間に対するパーセントで示すパーセント カウンタ。時間を 100 ナノ秒 (ns) 単位で計測します。このタイプのカウンタは、あるコンポーネントのある時点でのアクティビティを計測するようにデザインされています。 

数式 : (N 1 - N 0) / (D 1 - D 0) × 100 で計算されます。ここで、分子は監視対象コンポーネントがアクティブだったサンプル間隔の一部分を表し、分母はサンプル間隔の経過時間合計を表します。

このタイプのカウンタには、Processor\ % User Time などがあります。

Timer100NsInverseサンプル間隔中に記録されたアクティブな時間の平均パーセントを示すパーセント カウンタ。 

逆カウンタです。このタイプのカウンタは、サービスがアクティブでなかった時間を計測し、アクティブな時間のパーセントを 100 パーセントから減算することによってアクティブな時間を計算します。

数式 : (1- ((N 1 - N 0) / (D 1 - D 0))) × 100 で計算されます。ここで、分子はその間隔で監視対象コンポーネントがアクティブでなかった時間を表し、分母はサンプル間隔の経過時間合計を表します。

このタイプのカウンタには、Processor\ % Processor Time などがあります。

解説解説

いくつかのカウンタ タイプは生データを表しますが、1 つ以上のカウンタ サンプルに基づいて計算される値を表すカウンタ タイプもあります。使用できるカウンタ タイプは、次のカテゴリに分類されます。

パフォーマンス カウンタ データをサンプリングするとき、平均を表すカウンタ タイプを使用すると、生データ値が意味のある値になります。たとえば、生データ カウンタの NumberOfItems64 は、サンプルによってかなり異なるデータを示します。カウンタが返す値の平均を計算する数式は、(X 0 +X 1 +…+X n)/n です。ここで、各 X i は生のカウンタ サンプルです。

割合カウンタは、平均カウンタと似ていますが、リソースが使用されるに従い割合が増加する場合により役立ちます。平均をすばやく計算する数式は ((X n -X 0)/(T n -T 0)) / 頻度です。ここで、各 X i はカウンタ サンプル、各 T i は、対応するサンプルが取得された時刻です。結果は、1 秒あたりの平均使用率です。

メモメモ

特に指定がない場合、時間の単位は秒です。

アプリケーションを実装するとき (カスタム パフォーマンス カウンタを作成し、書き込むとき)、計算で使用される付属するベース カウンタに依存するパフォーマンス カウンタ タイプを使用することがあります。ベース カウンタは、アプリケーションで使用する CounterCreationDataCollection コレクションの中で、関連付けられているカウンタの直後に置く必要があります。ベース カウンタ タイプと、それぞれに対応するパフォーマンス カウンタ タイプの一覧を次の表に示します。

ベース カウンタ タイプ

パフォーマンス カウンタ タイプ

AverageBase

AverageTimer32

AverageCount64

CounterMultiBase

CounterMultiTimer

CounterMultiTimerInverse

CounterMultiTimer100Ns

CounterMultiTimer100NsInverse

RawBase

RawFraction

SampleBase

SampleCounter

SampleFraction

使用例使用例

PerformanceCounterType 列挙体に含まれるカウンタ タイプのいくつかを次に示します。

AverageCount64

Visual Basic
Imports System
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()
      
      SetupCategory()
      CreateCounters()
      CollectSamples(samplesList)
      CalculateResults(samplesList)
   End Sub 'Main
    
   
   
   Private Shared Function
 SetupCategory() As Boolean
      If Not PerformanceCounterCategory.Exists("AverageCounter64SampleCategory")
 Then
         
         Dim CCDC As New
 CounterCreationDataCollection()
         
         ' Add the counter.
         Dim averageCount64 As New
 CounterCreationData()
         averageCount64.CounterType = PerformanceCounterType.AverageCount64
         averageCount64.CounterName = "AverageCounter64Sample"
         CCDC.Add(averageCount64)
         
         ' Add the base counter.
         Dim averageCount64Base As New
 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
      End If
   End Function 'SetupCategory
   
   
   Private Shared Sub CreateCounters()
      ' Create the counters.

      PC = New PerformanceCounter("AverageCounter64SampleCategory",
 "AverageCounter64Sample", False)
      
      BPC = New PerformanceCounter("AverageCounter64SampleCategory",
 "AverageCounter64SampleBase", False)
      
      
      PC.RawValue = 0
      BPC.RawValue = 0
   End Sub 'CreateCounters
   
   
   Private Shared Sub CollectSamples(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 + " = " + value))
         
         PC.IncrementBy(value)
         
         BPC.Increment()
         
         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 'CollectSamples
    
   
   Private Shared Sub CalculateResults(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))))
         
         ' 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 'CalculateResults
   
   
   
   
   '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
   '    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(s0 As CounterSample, 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(s
 As CounterSample)
      Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
      Console.WriteLine("Sample values - " + ControlChars.Lf
 + ControlChars.Cr)
      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 'OutputSample
End Class 'App
C#
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();

        SetupCategory();
        CreateCounters();
        CollectSamples(samplesList);
        CalculateResults(samplesList);

    }
    

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

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
            
            // Add the counter.
            CounterCreationData averageCount64 = new CounterCreationData();
            averageCount64.CounterType = PerformanceCounterType.AverageCount64;
            averageCount64.CounterName = "AverageCounter64Sample";
            CCDC.Add(averageCount64);
            
            // Add the base counter.
            CounterCreationData averageCount64Base = new 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);
        }
    }
    
    private static void
 CreateCounters()
    {
        // Create the counters.

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

        BPC = new PerformanceCounter("AverageCounter64SampleCategory",
 
            "AverageCounter64SampleBase", 
            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 j = 0; j < 100; j++) 
        {
            
            int value = r.Next(1, 10);
            Console.Write(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);
        }

    }
    
    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("++++++++++++++++++++++");
    }
}
C++
#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 );
}
J#
import System.*;  
import System.Collections.*;  
import System.Collections.Specialized.*;  
import System.Diagnostics.*;  

public class App
{
    private static PerformanceCounter pc;
    private static PerformanceCounter bpc;

    public static void main(String[]
 args)
    {
        ArrayList samplesList = new ArrayList();
        SetupCategory();
        CreateCounters();
        CollectSamples(samplesList);
        CalculateResults(samplesList);
    } //main

    private static boolean SetupCategory()
    {
        if (!(PerformanceCounterCategory.Exists(
            "AverageCounter64SampleCategory"))) {
            CounterCreationDataCollection ccdc = 
                new CounterCreationDataCollection();
            // Add the counter.
            CounterCreationData averageCount64 = new CounterCreationData();
            averageCount64.
                set_CounterType(PerformanceCounterType.AverageCount64);
            averageCount64.set_CounterName("AverageCounter64Sample");
            ccdc.Add(averageCount64);
            // Add the base counter.
            CounterCreationData averageCount64Base = new CounterCreationData();
            averageCount64Base.set_CounterType(PerformanceCounterType.
                AverageBase);
            averageCount64Base.set_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;
        }
    } //SetupCategory

    private static void
 CreateCounters()
    {
        // Create the counters.
        pc = new PerformanceCounter("AverageCounter64SampleCategory"
,
            "AverageCounter64Sample", false);
        bpc = new PerformanceCounter("AverageCounter64SampleCategory"
,
            "AverageCounter64SampleBase", false);
        pc.set_RawValue(0);
        bpc.set_RawValue(0);
    } //CreateCounters

    private static void
 CollectSamples(ArrayList samplesList)
    {
        Random r = new Random(DateTime.get_Now().get_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);
            bpc.Increment();

            if (j % 10 == 9) {
                OutputSample(pc.NextSample());
                samplesList.Add(pc.NextSample());
            }
            else {
                Console.WriteLine();
            }
            System.Threading.Thread.Sleep(50);
        }
    } //CollectSamples

    private static void
 CalculateResults(ArrayList samplesList)
    {
        for (int i = 0; i < samplesList.get_Count()
 - 1; i++) {
            // Output the sample.
            OutputSample((CounterSample)samplesList.get_Item(i));
            OutputSample((CounterSample)samplesList.get_Item(i + 1));
            // Use.NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " 
                + CounterSampleCalculator.ComputeCounterValue((CounterSample)
                samplesList.get_Item(i), 
                (CounterSample)samplesList.get_Item(i + 1)));
            // Calculate the counter value manually.
            Console.WriteLine("My computed counter value = "
                + MyComputeCounterValue((CounterSample)samplesList.get_Item(i),
                (CounterSample)samplesList.get_Item(i + 1)));
        }
    } //CalculateResults

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

    // 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.get_BaseValue());
        Console.WriteLine("   CounterFrequency = " + s.get_CounterFrequency());
        Console.WriteLine("   CounterTimeStamp = " + s.get_CounterTimeStamp());
        Console.WriteLine("   CounterType      = " + s.get_CounterType());
        Console.WriteLine("   RawValue         = " + s.get_RawValue());
        Console.WriteLine("   SystemFrequency  = " + s.get_SystemFrequency());
        Console.WriteLine("   TimeStamp        = " + s.get_TimeStamp());
        Console.WriteLine("   TimeStamp100nSec = " + s.get_TimeStamp100nSec());
        Console.WriteLine("++++++++++++++++++++++");
    } //OutputSample
} //App

AverageTimer32

Visual Basic
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.InteropServices
Imports Microsoft.VisualBasic

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
C#
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();

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

ElapsedTime

Visual Basic
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.InteropServices
Imports Microsoft.VisualBasic

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.",
 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(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
C#
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 ( !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."
,
                    CCDC);

        }
        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("++++++++++++++++++++++");
    }
}
C++
#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();
}
J#
import System.*;
import System.Collections.*;
import System.Collections.Specialized.*;
import System.Diagnostics.*;
import System.Runtime.InteropServices.*;

public class App
{
    public static void main(String[]
 args)
    {
        CollectSamples();
    } //main

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

        if (!(PerformanceCounterCategory.Exists(categoryName)))
 {
            CounterCreationDataCollection ccdc = 
                new CounterCreationDataCollection();
            // Add the counter.
            CounterCreationData eTimeData = new CounterCreationData();
            eTimeData.set_CounterType(PerformanceCounterType.ElapsedTime);
            eTimeData.set_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 = new PerformanceCounter(categoryName
,
            counterName, false);
        // Initialize the counter.
        pc.set_RawValue(Stopwatch.GetTimestamp());
        DateTime start = DateTime.get_Now();
        // Loop for the samples.
        for (int j = 0; j < 100; j++) {
            // Output the values.
            if (j % 10 == 9) {
                Console.WriteLine("NextValue() = " + ((Single)pc.NextValue()).
                    ToString());
                Console.WriteLine("Actual elapsed time = "
                    + DateTime.get_Now().Subtract(start).ToString());
                OutputSample(pc.NextSample());
            }
            // Reset the counter on every 20th iteration.
            if (j % 20 == 0) {
                pc.set_RawValue(Stopwatch.GetTimestamp());
                start = DateTime.get_Now();
            }
            System.Threading.Thread.Sleep(50);
        }
        Console.WriteLine("Elapsed time = " + DateTime.get_Now().
            Subtract(start).ToString());
    } //CollectSamples

    private static void
 OutputSample(CounterSample s)
    {
        Console.WriteLine("\r\n+++++++++++");
        Console.WriteLine("Sample values - \r\n");
        Console.WriteLine("   BaseValue        = " + s.get_BaseValue());
        Console.WriteLine("   CounterFrequency = " + s.get_CounterFrequency());
        Console.WriteLine("   CounterTimeStamp = " + s.get_CounterTimeStamp());
        Console.WriteLine("   CounterType      = " + s.get_CounterType());
        Console.WriteLine("   RawValue         = " + s.get_RawValue());
        Console.WriteLine("   SystemFrequency  = " + s.get_SystemFrequency());
        Console.WriteLine("   TimeStamp        = " + s.get_TimeStamp());
        Console.WriteLine("   TimeStamp100nSec = " + s.get_TimeStamp100nSec());
        Console.WriteLine("++++++++++++++++++++++");
    } //OutputSample
} //App

NumberOfItems32

Visual Basic
Imports System
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()
      
      SetupCategory()
      CreateCounters()
      CollectSamples(samplesList)
      CalculateResults(samplesList)
   End Sub 'Main
   
   
   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.", 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 'CreateCounters
    
   
   Private Shared Sub CollectSamples(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 + " = " + value))
         
         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 'CollectSamples
    
   
   
   
   Private Shared Sub CalculateResults(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))))
         
         ' 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 'CalculateResults
   
   
   
   
   '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
   '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
   Private Shared Function
 MyComputeCounterValue(s0 As CounterSample, 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(s
 As CounterSample)
      Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
      Console.WriteLine("Sample values - " + ControlChars.Lf
 + ControlChars.Cr)
      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 'OutputSample
End Class 'NumberOfItems64
C#
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();

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


    
}
C++
#using <System.dll>

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

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

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

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

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

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

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

   // Loop for the samples.
   for ( int j = 0; j < 100; j++ )
   {
      int value = r->Next( 1, 10 );
      Console::Write( "{0} = {1}", j, value );
      PC->IncrementBy( value );
      if ( (j % 10) == 9 )
      {
         OutputSample( PC->NextSample() );
         samplesList->Add( PC->NextSample() );
      }
      else
            Console::WriteLine();
      System::Threading::Thread::Sleep( 50 );

   }
}

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

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

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

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

NumberOfItems64

Visual Basic
Imports System
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()
      
      SetupCategory()
      CreateCounters()
      CollectSamples(samplesList)
      CalculateResults(samplesList)
   End Sub 'Main
   
   
   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.", 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 'CreateCounters
    
   
   Private Shared Sub CollectSamples(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 + " = " + value))
         
         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 'CollectSamples
    
   
   Private Shared Sub CalculateResults(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))))
         
         ' 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 'CalculateResults
   
   
   
   
   '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
   '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
   Private Shared Function
 MyComputeCounterValue(s0 As CounterSample, 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(s
 As CounterSample)
      Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
      Console.WriteLine("Sample values - " + ControlChars.Lf
 + ControlChars.Cr)
      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 'OutputSample
End Class 'NumberOfItems64
C#
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();

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

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

RateOfCountsPerSecond32

Visual Basic
Imports System
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()
      
      SetupCategory()
      CreateCounters()
      CollectSamples(samplesList)
      CalculateResults(samplesList)
   End Sub 'Main
   
   
   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.", 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 'CreateCounters
    
   
   Private Shared Sub CollectSamples(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 + " = " + value))
         
         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 'CollectSamples
   
   
   Private Shared Sub CalculateResults(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))))
         
         ' 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 'CalculateResults
   
   
   
   
   
   '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
   '    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(s0 As CounterSample, 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(s
 As CounterSample)
      Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
      Console.WriteLine("Sample values - " + ControlChars.Lf
 + ControlChars.Cr)
      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 'OutputSample
End Class 'App
C#
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();

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

}
C++
#using <System.dll>

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

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


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

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

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

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

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

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

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

   // Loop for the samples.
   for ( int j = 0; j < 100; j++ )
   {
      int value = r->Next( 1, 10 );
      PC->IncrementBy( value );
      Console::Write( "{0} = {1}", j, value );
      if ( (j % 10) == 9 )
      {
         Console::WriteLine( ";       NextValue() = {0}", PC->NextValue()
 );
         OutputSample( PC->NextSample() );
         samplesList->Add( PC->NextSample() );
      }
      else
            Console::WriteLine();
      System::Threading::Thread::Sleep( 50 );
   }
}

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

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

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

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

RateOfCountsPerSecond64

Visual Basic
Imports System
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()
      
      SetupCategory()
      CreateCounters()
      CollectSamples(samplesList)
      CalculateResults(samplesList)
   End Sub 'Main
   
   
   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.", 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 'CreateCounters
    
   
   Private Shared Sub CollectSamples(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 + " = " + value))
         
         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 'CollectSamples
    
   
   Private Shared Sub CalculateResults(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))))
         
         ' 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 'CalculateResults
   
   
   
   
   '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
   '    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(s0 As CounterSample, 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(s
 As CounterSample)
      Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
      Console.WriteLine("Sample values - " + ControlChars.Lf
 + ControlChars.Cr)
      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 'OutputSample
End Class 'App
C#
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();

        SetupCategory();
        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.", 
                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("++++++++++++++++++++++");
    }
}
C++
#using <System.dll>

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

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

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

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

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

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

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

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

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

   // Loop for the samples.
   for ( int j = 0; j < 100; j++ )
   {
      int value = r->Next( 1, 10 );
      PC->IncrementBy( value );
      Console::Write( "{0} = {1}", j, value );
      if ( (j % 10) == 9 )
      {
         Console::WriteLine( ";       NextValue() = {0}", PC->NextValue()
 );
         OutputSample( PC->NextSample() );
         samplesList->Add( PC->NextSample() );
      }
      else
            Console::WriteLine();
      System::Threading::Thread::Sleep( 50 );
   }
}

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

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

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

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

RawFraction

Visual Basic
Imports System
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()
      
      SetupCategory()
      CreateCounters()
      CollectSamples(samplesList)
      CalculateResults(samplesList)
   End Sub 'Main
   
   
   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.",
 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 'CreateCounters
   
   
   Private Shared Sub CollectSamples(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 + " = " + 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 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 'CollectSamples
    
   
   
   Private Shared Sub CalculateResults(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))))
         
         ' Calculate the counter value manually.
         Console.WriteLine(("My computed counter value = "
 + MyComputeCounterValue(CType(samplesList(i), CounterSample))))
      Next i
   End Sub 'CalculateResults
    
   
   '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
   ' 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(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(s
 As CounterSample)
      Console.WriteLine("+++++++++++")
      Console.WriteLine("Sample values - " + ControlChars.Lf
 + ControlChars.Cr)
      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 'OutputSample
End Class 'App
C#
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();

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



}
C++
#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 );
}
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0、1.1、1.0
参照参照
関連項目
System.Diagnostics 名前空間
PerformanceCounter クラス

急上昇のことば

検証
定義
高じる
汚染
確認

英和和英テキスト翻訳

英語⇒日本語日本語⇒英語

辞書ショートカット

カテゴリ一覧

全て

＋ ビジネス

＋ 業界用語

＋ コンピュータ

＋ 電車

＋ 自動車・バイク

＋ 船

＋ 工学

＋ 建築・不動産

＋ 学問

＋ 文化

＋ 生活

＋ ヘルスケア

＋ 趣味

＋ スポーツ

＋ 生物

＋ 食品

＋ 人名

＋ 方言

＋ 辞書・百科事典

すべての辞書の索引

あいうえお
かきくけこ
さしすせそ
たちつてと
なにぬねの
はひふへほ
まみむめも
やゆよ
らりるれろ
わをん
がぎぐげご
ざじずぜぞ
だぢづでど
ばびぶべぼ
ぱぴぷぺぽ
ＡＢＣＤＥ
ＦＧＨＩＪ
ＫＬＭＮＯ
ＰＱＲＳＴ
ＵＶＷＸＹ
Ｚ
１２３４５
６７８９０
記号

Weblioのサービス

「PerformanceCounterType 列挙体」の関連用語

1
PerformanceCounter.CounterType プロパティ
.NET Framework クラス ライブラリ リファレンス
54% |||||

2
CounterCreationData.CounterType プロパティ
.NET Framework クラス ライブラリ リファレンス
52% |||||

3
CounterCreationData コンストラクタ
.NET Framework クラス ライブラリ リファレンス
50% |||||

4
PerformanceCounter.IncrementBy メソッド
.NET Framework クラス ライブラリ リファレンス
14% |||||

5
PerformanceCounter.NextValue メソッド
.NET Framework クラス ライブラリ リファレンス
14% |||||

6
PerformanceCounter.NextSample メソッド
.NET Framework クラス ライブラリ リファレンス
14% |||||

PerformanceCounterType 列挙体のお隣キーワード

PerformanceCounterPermission クラス

PerformanceCounterPermission コンストラクタ

PerformanceCounterPermission プロパティ

PerformanceCounterPermission メソッド

PerformanceCounterPermission メンバ

PerformanceCounterPermission.PermissionEntries プロパティ

PerformanceCounterType 列挙体

PerformanceCountersElement クラス

PerformanceCountersElement コンストラクタ

PerformanceCountersElement プロパティ

PerformanceCountersElement メソッド

PerformanceCountersElement メンバ

PerformanceCountersElement.Enabled プロパティ

検索ランキング

   

 英語⇒日本語
日本語⇒英語		    


PerformanceCounterType 列挙体のページの著作権

   
日本マイクロソフト株式会社日本マイクロソフト株式会社
© 2026 Microsoft.All rights reserved.

©2026 GRAS Group, Inc.RSS