PerformanceCounterType 列挙体とは何？わかりやすく解説 Weblio辞書

すべての辞書から再検索する

.NET Framework クラスライブラリリファレンス

索引トップ用語の索引ランキング

PerformanceCounterType 列挙体

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

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

Visual Basic (宣言)

Public Enumeration PerformanceCounterType

Visual Basic (使用法)

Dim instance As PerformanceCounterType

public enum PerformanceCounterType

C++

public enum class PerformanceCounterType

public enum PerformanceCounterType

JScript

public enum PerformanceCounterType

メンバ

	メンバ名	説明
	AverageBase	AverageTimer32 や AverageCount64 など、時間または回数の平均を計算するために使用されるベースカウンタ。"操作ごとの時間" または "操作ごとの回数" を表すカウンタの計算に使用する分母を格納します。
	AverageCount64	処理された項目の数を操作中の平均で示す平均カウンタ。このタイプのカウンタは、完了した処理数に対する処理された項目の比率を表示します。比率は、最後の間隔で処理された項目数と、最後の間隔で完了した操作の数を比較することによって計算されます。数式 : (N ₁ -N ₀)/(B ₁ -B ₀) で計算されます。ここで、N ₁ および N ₀ はパフォーマンスカウンタの読み取りを表し、B ₁ と B ₀ はそれぞれに対応する AverageBase 値を表します。つまり、分子はサンプル間隔中に処理された項目数を表し、分母はサンプル間隔中に完了した操作の数を表します。このタイプのカウンタには、PhysicalDisk\ Avg.Disk Bytes/Transfer などがあります。
	AverageTimer32	処理または操作を完了するまでに経過した時間の平均を計測する平均カウンタ。このタイプのカウンタは、サンプル間隔で完了した処理または操作に対する、その間隔での経過時間の合計の比率を表示します。このカウンタタイプは、システム時計のタイマ刻みで時間を計測します。数式 : ((N ₁ -N ₀)/F)/(B ₁ -B ₀) で計算されます。ここで、N ₁ と N ₀ はパフォーマンスカウンタの読み取り、B ₁ と B ₀ はそれぞれに対応する AverageBase 値、F は 1 秒あたりのタイマ刻み数を表します。F の値が数式で考慮されるため、結果は秒単位で表示されます。つまり、分子は最後のサンプル間隔中にカウントされたタイマ刻み数を表し、F はタイマ刻みの頻度を表し、分母は最後のサンプル間隔中に完了した操作の数を表します。このタイプのカウンタには、PhysicalDisk\ Avg.Disk sec/Transfer などがあります。
	CounterDelta32	2 つの最新のサンプル間隔を使用して、その間の計測対象の属性の変化を示す差カウンタ。数式 : N ₁ -N ₀ で計算されます。ここで、N ₁ および N ₀ はパフォーマンスカウンタの読み取りを表します。
	CounterDelta64	2 つの最新のサンプル間隔を使用して、その間の計測対象の属性の変化を示す差カウンタ。CounterDelta32 カウンタタイプと同じですが、大きな値を処理できるように、大きなフィールドを使用します。数式 : N ₁ -N ₀ で計算されます。ここで、N ₁ および N ₀ はパフォーマンスカウンタの読み取りを表します。
	CounterMultiBase	サンプリングする項目の数を示すベースカウンタ。複数の似た項目について、タイミングをとりながらサンプリングされた項目の平均を取得する計算で、分母として使用されます。CounterMultiTimer、CounterMultiTimerInverse、CounterMultiTimer100Ns、および CounterMultiTimer100NsInverse で使用します。
	CounterMultiTimer	1 つ以上のコンポーネントのアクティブな時間をサンプル間隔の合計時間に対するパーセントで表示するパーセントカウンタ。分子は、同時に運用されるコンポーネントのアクティブな時間を記録するため、結果のパーセントは 100 パーセントを超えることがあります。このカウンタはマルチタイマです。マルチタイマは、プロセッサやディスクなど、コンポーネントの複数のインスタンスからデータを収集します。このカウンタタイプは、システムパフォーマンスタイマのタイマ刻みの単位で時間を計測するという点で、100 ナノ秒単位で計測する CounterMultiTimer100Ns と異なります。数式 : ((N ₁ - N ₀) / (D ₁ - D ₀)) × 100 / B で計算されます。ここで、N ₁ と N ₀ はパフォーマンスカウンタの読み取り、D ₁ と D ₀ はそれぞれに対応する時刻の読み取り (システムパフォーマンスタイマのタイマ刻み単位) を表し、変数 B は監視対象コンポーネントのベースカウンタ (カウンタタイプが CounterMultiBase のベースカウンタを使用) を表します。つまり、分子は、監視するコンポーネントがアクティブだったサンプル間隔の一部分を表し、分母は、サンプル間隔の経過時間の合計を表します。
	CounterMultiTimer100Ns	1 つ以上のコンポーネントのアクティブな時間をサンプル間隔の合計時間に対するパーセントで示すパーセントカウンタ。時間を 100 ナノ秒 (ns) 単位で計測します。このカウンタタイプはマルチタイマです。マルチタイマは、プロセッサやディスクなど、コンポーネントの複数のインスタンスを監視するようにデザインされています。数式 : ((N ₁ - N ₀) / (D ₁ - D ₀)) × 100 / B で計算されます。ここで、N ₁ と N ₀ はパフォーマンスカウンタの読み取り、D ₁ と D ₀ はそれぞれに対応する時刻の読み取り (100 ナノ秒単位) を表し、変数 B は監視対象コンポーネントのベースカウンタ (カウンタタイプが CounterMultiBase のベースカウンタを使用) を表します。つまり、分子は、監視するコンポーネントがアクティブだったサンプル間隔の一部分を表し、分母は、サンプル間隔の経過時間の合計を表します。
	CounterMultiTimer100NsInverse	1 つ以上のコンポーネントのアクティブな時間をサンプル間隔の合計時間に対するパーセントで示すパーセントカウンタ。このカウンタタイプは、時間を 100 ナノ秒 (ns) 単位で計測します。コンポーネントがアクティブでなかった時間を計測し、監視するオブジェクト数かける 100 パーセントから計測値を減算することによってアクティブな時間を導出します。このカウンタタイプは逆マルチタイマです。マルチタイマは、プロセッサやディスクなど、コンポーネントの複数のインスタンスを監視するようにデザインされています。逆カウンタは、コンポーネントがアクティブでない時間を計測し、アクティブでない時間の計測値からアクティブな時間を導出します。数式 : (B - ((N ₁ - N ₀) / (D ₁ - D ₀))) × 100 で計算されます。ここで、分母はサンプル間隔の経過時間合計を表し、分子はその間隔で監視対象コンポーネントがアクティブでなかった時間を表し、B はカウンタタイプが CounterMultiBase のベースカウンタを使用して監視するコンポーネントの数を表します。
	CounterMultiTimerInverse	1 つ以上のコンポーネントのアクティブな時間をサンプル間隔の合計時間に対するパーセントで示すパーセントカウンタ。コンポーネントがアクティブでなかった時間を計測し、監視するオブジェクト数かける 100 パーセントから計測値を減算することによってアクティブな時間を導出します。このカウンタタイプは逆マルチタイマです。マルチタイマは、プロセッサやディスクなど、コンポーネントの複数のインスタンスを監視します。逆カウンタは、コンポーネントがアクティブでない時間を計測し、この計測値からアクティブな時間を導出します。このカウンタは、システムパフォーマンスタイマのタイマ刻みの単位で時間を計測するという点で、100 ナノ秒単位で計測する CounterMultiTimer100NsInverse と異なります。数式 : (B - ((N ₁ - N ₀) / (D ₁ - D ₀))) × 100 で計算されます。ここで、分母はサンプル間隔の経過時間合計を表し、分子はその間隔で監視対象コンポーネントがアクティブでなかった時間を表し、B はカウンタタイプが CounterMultiBase のベースカウンタを使用して監視するコンポーネントの数を表します。
	CounterTimer	コンポーネントがアクティブだった平均時間をサンプル時間合計に対するパーセントで示すパーセントカウンタ。数式 : (N ₁ - N ₀) / (D ₁ - D ₀) で計算されます。ここで、N ₁ と N ₀ はパフォーマンスカウンタの読み取りを表し、D ₁ と D ₀ はそれぞれに対応する時刻の読み取りを表します。つまり、分子は、監視するコンポーネントがアクティブだったサンプル間隔の一部分を表し、分母は、サンプル間隔の経過時間の合計を表します。
	CounterTimerInverse	サンプル間隔中に記録されたアクティブな時間の平均パーセントを表示するパーセントカウンタ。このカウンタの値は、サービスがアクティブでなかった時間のパーセントを監視し、この値を 100 パーセントから減算することによって計算されます。逆カウンタタイプです。逆カウンタは、コンポーネントがアクティブでない時間を計測し、この計測値からアクティブな時間を導出します。このカウンタタイプは CounterTimer100NsInv と同じですが、100 ナノ秒単位ではなく、システムパフォーマンスタイマのタイマ刻みの単位で時間を計測するという点が異なります。数式 : (1- ((N ₁ - N ₀) / (D ₁ - D ₀))) × 100 で計算されます。ここで、分子はその間隔で監視対象コンポーネントがアクティブでなかった時間を表し、分母はサンプル間隔の経過時間合計を表します。
	CountPerTimeInterval32	一定時間の間のリソースに対するキューの長さの平均を監視するようにデザインされた平均カウンタ。間隔の存続期間で分割された最後の 2 つのサンプル間隔の間で監視されたキューの長さの差を示します。このカウンタタイプは、通常、キューに置かれた項目または待機中の項目の数を追跡するために使用されます。数式 : (N ₁ - N ₀) / (D ₁ - D ₀) で計算されます。ここで、分子はキューの項目数を表し、分母は最後のサンプル間隔の経過時間を表します。
	CountPerTimeInterval64	一定時間の間のリソースに対するキューの長さの平均を監視する平均カウンタ。このカウンタタイプは、間隔の存続期間で分割された最後の 2 つのサンプル間隔の間で監視されたキューの長さの差を示します。このカウンタタイプは、CountPerTimeInterval32 と同じですが、大きな値を処理できるように、大きなフィールドを使用します。このカウンタタイプは、通常、キューに置かれたまたは待機中の大量または多数の項目の数を追跡するために使用されます。数式 : (N ₁ - N ₀) / (D ₁ - D ₀) で計算されます。ここで、分子はキューの項目数を表し、分母はサンプル間隔の経過時間を表します。
	ElapsedTime	コンポーネントまたはプロセスが開始された時間と、この値が計算された時間の間の合計時間を示す差タイマ。数式 : (D ₀ - N ₀) / F で計算されます。ここで、D ₀ は現在時刻を表し、N ₀ はオブジェクトが開始された時刻を表し、F は 1 秒間に経過する時間単位数を表します。F の値が数式で考慮されるため、結果は秒単位で表示されます。このタイプのカウンタには、System\ System Up Time などがあります。
	NumberOfItems32	最新の記録値を示す即時カウンタ。項目または操作の単純なカウントを保持するときなどに使用します。数式 : なし。平均は表示されませんが、収集した生データが表示されます。このタイプのカウンタには、Memory\Available Bytes などがあります。
	NumberOfItems64	最新の記録値を示す即時カウンタ。大量の項目または操作の単純なカウントを保持するときなどに使用します。NumberOfItems32 と同じですが、大きな値を処理できるように、大きなフィールドを使用します。数式 : なし。平均は表示されませんが、収集した生データが表示されます。
	NumberOfItemsHEX32	最新の記録値を 16 進形式で示す即時カウンタ。項目または操作の単純なカウントを保持するときなどに使用します。数式 : なし。平均は表示されませんが、収集した生データが表示されます。
	NumberOfItemsHEX64	最新の記録値を示す即時カウンタ。大量の項目または操作の単純なカウントを保持するときなどに使用します。NumberOfItemsHEX32 と同じですが、大きな値を処理できるように、大きなフィールドを使用します。数式 : なし。平均は表示されませんが、収集した生データが表示されます。
	RateOfCountsPerSecond32	サンプル間隔の各秒で完了した平均操作数を示す差カウンタ。このタイプのカウンタは、システム時計のタイマ刻みで時間を計測します。数式 : (N ₁ - N ₀) / ((D ₁ -D ₀) / F) で計算されます。ここで、N ₁ と N ₀ はパフォーマンスカウンタの読み取り、D ₁ と D ₀ はそれぞれに対応する時刻の読み取り、F は 1 秒あたりのタイマ刻み数を表します。つまり、分子は最後のサンプル間隔中に実行された操作の数を表し、分母は最後のサンプル間隔中に経過したタイマ刻み数を表し、F はタイマ刻みの頻度を表します。F の値が数式で考慮されるため、結果は秒単位で表示されます。このタイプのカウンタには、System\ File Read Operations/sec などがあります。
	RateOfCountsPerSecond64	サンプル間隔の各秒で完了した平均操作数を示す差カウンタ。このタイプのカウンタは、システム時計のタイマ刻みで時間を計測します。このカウンタタイプは RateOfCountsPerSecond32 タイプと同じですが、バイト転送速度など 1 秒ごとに大量の項目数または操作数を追跡するために、大きな値を処理できるように、大きなフィールドを使用します。数式 : (N ₁ - N ₀) / ((D ₁ -D ₀) / F) で計算されます。ここで、N ₁ と N ₀ はパフォーマンスカウンタの読み取り、D ₁ と D ₀ はそれぞれに対応する時刻の読み取り、F は 1 秒あたりのタイマ刻み数を表します。つまり、分子は最後のサンプル間隔中に実行された操作の数を表し、分母は最後のサンプル間隔中に経過したタイマ刻み数を表し、F はタイマ刻みの頻度を表します。F の値が数式で考慮されるため、結果は秒単位で表示されます。このタイプのカウンタには、System\ File Read Bytes/sec などがあります。
	RawBase	通常の算術的な分数を表すカウンタの分母を格納するベースカウンタ。RawFraction 値の計算で分母として使用する前に、この値がゼロを超えることを確認してください。
	RawFraction	セットに対するサブセットの比率をパーセントで示す即時パーセントカウンタ。たとえば、ディスクで使用中のバイト数とディスクの総バイト数を比較します。このタイプのカウンタは、一定期間の平均ではなく、現在のパーセントだけを表示します。数式 : (N ₀ / D ₀) × 100 で計算されます。ここで、D ₀ は計測対象の属性 (カウンタタイプが RawBase のベースカウンタを使用) を表し、N ₀ は、その属性の 1 つのコンポーネントを表します。このタイプのカウンタには、Paging File\% Usage Peak などがあります。
	SampleBase	取得したサンプリング割り込みの回数を格納するベースカウンタ。サンプリング分数の分母として使用されます。サンプリング分数は、サンプリング割り込みに対して 1 (または true) だったサンプルの数です。SampleCounter または SampleFraction の計算で分母として使用する前に、この値が 0 より大きいことを確認してください。
	SampleCounter	1 秒間に完了した平均操作数を示す平均カウンタ。このタイプのカウンタがデータをサンプリングすると、各サンプリング割り込みが 1 または 0 を返します。カウンタデータは、サンプリングされたデータの数です。システムパフォーマンスタイマのタイマ刻みの時間単位を計測します。数式 : (N ₁ – N ₀) / ((D ₁ – D ₀) / F)。ここで、分子 (N) は実行される操作の数を表し、分母 (D) はシステムパフォーマンスタイマのタイマ刻み単位で示した経過時間を表し、F は 1 秒間のタイマ刻み数を表します。F が数式で考慮されるため、結果は秒単位で表示されます。
	SampleFraction	最後の 2 つのサンプル間隔中に発生したすべての操作に対するヒットカウントの平均比率を示すパーセントカウンタ。数式 : ((N ₁ - N ₀) / (D ₁ - D ₀)) × 100 で計算されます。ここで、分子は最後のサンプル間隔で成功した操作の数を表し、分母は、カウンタタイプが SampleBase のカウンタを使用して、サンプル間隔で完了したすべての操作 (計測対象のタイプの操作) の数の変化を表します。このタイプのカウンタには、Cache\Pin Read Hits % などがあります。
	Timer100Ns	コンポーネントのアクティブな時間をサンプル間隔の合計経過時間に対するパーセントで示すパーセントカウンタ。時間を 100 ナノ秒 (ns) 単位で計測します。このタイプのカウンタは、あるコンポーネントのある時点でのアクティビティを計測するようにデザインされています。数式 : (N ₁ - N ₀) / (D ₁ - D ₀) × 100 で計算されます。ここで、分子は監視対象コンポーネントがアクティブだったサンプル間隔の一部分を表し、分母はサンプル間隔の経過時間合計を表します。このタイプのカウンタには、Processor\ % User Time などがあります。
	Timer100NsInverse	サンプル間隔中に記録されたアクティブな時間の平均パーセントを示すパーセントカウンタ。逆カウンタです。このタイプのカウンタは、サービスがアクティブでなかった時間を計測し、アクティブな時間のパーセントを 100 パーセントから減算することによってアクティブな時間を計算します。数式 : (1- ((N ₁ - N ₀) / (D ₁ - D ₀))) × 100 で計算されます。ここで、分子はその間隔で監視対象コンポーネントがアクティブでなかった時間を表し、分母はサンプル間隔の経過時間合計を表します。このタイプのカウンタには、Processor\ % Processor Time などがあります。

解説

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

平均 : 一定期間の値を計測し、最後の 2 つの計測値の平均を表示します。平均カウンタは、使用するサンプルの数値を追跡するベースカウンタに関連付けられます。
差 : 最後の測定値をその前の測定値から減算し、結果が正の場合は差を表示します。負の場合はゼロを表示します。
即時 : 直前の測定値を表示します。
パーセント : 計算した値をパーセントとして表示します。
割合 : 増加するイベントの回数を一定期間サンプリングし、回数の値の変化をアクティビティの割合を表示する期間で変化した値で除算します。

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

割合カウンタは、平均カウンタと似ていますが、リソースが使用されるに従い割合が増加する場合により役立ちます。平均をすばやく計算する数式は ((X _n -X ₀)/(T _n -T ₀)) / 頻度です。ここで、各 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

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

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

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

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

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

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

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

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

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

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 クラス

このページでは「.NET Framework クラスライブラリリファレンス」からPerformanceCounterType 列挙体を検索した結果を表示しています。
Weblioに収録されているすべての辞書からPerformanceCounterType 列挙体を検索する場合は、下記のリンクをクリックしてください。

全ての辞書からPerformanceCounterType 列挙体を検索

>> 「PerformanceCounterType 列挙体」を含む用語の索引
PerformanceCounterType 列挙体のページへのリンク

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

PerformanceCounterType 列挙体

「PerformanceCounterType 列挙体」の関連用語


	© 2025 Microsoft.All rights reserved.

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

PerformanceCounterType 列挙体

急上昇のことば

「PerformanceCounterType 列挙体」の関連用語

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