다음을 통해 공유


System.Diagnostics.PerformanceCounterType 열거형

이 문서에서는 이 API에 대한 참조 설명서에 대한 추가 설명서를 제공합니다.

열거형은 네이 PerformanceCounterType 티브 형식에 직접 매핑되는 성능 카운터 형식을 지정합니다.

일부 카운터 형식은 원시 데이터를 나타내고 다른 카운터 형식은 하나 이상의 카운터 샘플을 기반으로 하는 계산된 값을 나타냅니다. 다음 범주는 사용 가능한 카운터 유형을 분류합니다.

  • 평균: 시간에 따른 값을 측정하고 마지막 두 측정값의 평균을 표시합니다. 관련된 샘플 수를 추적하는 기본 카운터는 각 평균 카운터와 연결됩니다.
  • 차이점: 이전 측정값에서 마지막 측정값을 빼고 차이가 양수이면 표시하고 음수이면 0을 표시합니다.
  • 순간: 가장 최근의 측정값을 표시합니다.
  • 백분율: 계산된 값을 백분율로 표시합니다.
  • 속도: 시간이 지남에 따라 증가하는 이벤트 수를 샘플링하고 작업 속도를 표시하기 위해 시간 변경으로 개수 값의 변경을 나눕니다.

성능 카운터 데이터를 샘플링할 때 평균을 나타내는 카운터 형식을 사용하면 원시 데이터 값을 사용할 때 의미가 있습니다. 예를 들어 원시 데이터 카운터 NumberOfItems64 는 샘플에서 샘플로 상당히 무작위인 데이터를 노출할 수 있습니다. 카운터가 반환하는 값의 평균 계산에 대한 수식입니다(X 0 +X 1 +...+X n)/n. 여기서 각 X i는 원시 카운터 샘플입니다.

속도 카운터는 평균 카운터와 비슷하지만 리소스를 사용할 때 속도가 증가하는 상황에 더 유용합니다. 평균을 빠르게 계산하는 수식은 ((X n -X 0)/(T n -T 0)) /frequency이며, 여기서 각 X i는 카운터 샘플이고 각 T i는 해당 샘플을 가져온 시간입니다. 결과는 초당 평균 사용량입니다.

다중 타이머 카운터는 프로세서 또는 디스크와 같은 구성 요소의 둘 이상의 인스턴스에서 데이터를 수집합니다.

역 카운터는 구성 요소가 활성 상태가 아닌 시간을 측정하고 해당 측정값에서 활성 시간을 파생합니다.

참고 항목

달리 명시되지 않는 한 시간 기준은 초입니다.

(만들고 사용자 지정 성능 카운터를 기록할) 애플리케이션을 계측 하는 경우 계산에서 사용 되는 함께 제공 되는 기본 카운터를 사용 하는 성능 카운터 형식으로 작업 될 수 있습니다. 기본 카운터에서 연결된 된 카운터 직후 해야는 CounterCreationDataCollection 애플리케이션에서 사용 하는 컬렉션입니다. 다음 표에서는 해당 성능 카운터 형식을 가진 기본 카운터 형식을 나열합니다.

기본 카운터 형식 성능 카운터 유형
AverageBase AverageTimer32

AverageCount64
RawBase RawFraction
CounterMultiBase CounterMultiTimer

CounterMultiTimerInverse

CounterMultiTimer100Ns

CounterMultiTimer100NsInverse
SampleBase SampleFraction

다음은 계산된 값을 나타내는 일부 카운터에서 사용하는 수식입니다.

  • AverageCount64: (N1 - N0)/(B1 - B0), 여기서 N 1과 N 0은 성능 카운터 판독값이고 B1과 B0은 해당 AverageBase 값입니다. 따라서 숫자는 샘플 간격 동안 처리된 항목 수를 나타내고 분모는 샘플 간격 동안 완료된 작업 수를 나타냅니다.

  • AverageTimer32: ((N1 - N0)/F)/(B1 - B0), 여기서 N1과 N0은 성능 카운터 판독값이고, B1과 B0은 해당 AverageBase 값이고, F는 초당 틱 수입니다. 결과가 초 단위로 표시될 수 있도록 F 값이 수식에 고려됩니다. 따라서 숫자는 마지막 샘플 간격 동안 계산된 틱 수를 나타내고, F는 틱의 빈도를 나타내고, 분모는 마지막 샘플 간격 동안 완료된 작업 수를 나타냅니다.

  • CounterDelta32: N1 - N0, 여기서 N1 및 N0은 성능 카운터 판독값입니다.

  • CounterDelta64: N1 - N0, 여기서 N1 및 N0은 성능 카운터 판독값입니다.

  • CounterMultiTimer: ((N1 - N0) / (D1 - D0)) x 100/B, 여기서 N1과 N0은 성능 카운터 판독값이고, D1 및 D0은 시스템 성능 타이머의 틱에서 해당 시간 판독값이며, 변수 B는 모니터링되는 구성 요소의 기본 개수를 나타냅니다(형식 CounterMultiBase의 기본 카운터 사용). 따라서 분자는 모니터링되는 구성 요소가 활성화된 동안 샘플 간격의 부분을 나타내며 분모는 샘플 간격의 총 경과 시간을 나타냅니다.

  • CounterMultiTimer100Ns: ((N1 - N0) / (D1 - D0)) x 100/B, 여기서 N1과 N0은 성능 카운터 판독값이고, D1 및 D0은 100나노초 단위의 해당 시간 판독값이며, 변수 B는 모니터링되는 구성 요소의 기본 개수를 나타냅니다(형식 CounterMultiBase의 기본 카운터 사용). 따라서 분자는 모니터링되는 구성 요소가 활성화된 동안 샘플 간격의 부분을 나타내며 분모는 샘플 간격의 총 경과 시간을 나타냅니다.

  • CounterMultiTimer100NsInverse: (B - ((N1 - N0) / (D1 - D0)) x 100, 여기서 분모는 샘플 간격의 총 경과 시간을 나타내고, 분자는 모니터링되는 구성 요소가 비활성 상태였던 간격 동안의 시간을 나타내고, B는 형식 CounterMultiBase의 기본 카운터를 사용하여 모니터링되는 구성 요소의 수를 나타냅니다.

  • CounterMultiTimerInverse: (B- ((N1 - N0) / (D1 - D0)) x 100, 여기서 분모는 샘플 간격의 총 경과 시간을 나타내고, 분자는 모니터링되는 구성 요소가 비활성 상태였던 간격 동안의 시간을 나타내고, B는 형식 CounterMultiBase의 기본 카운터를 사용하여 모니터링되는 구성 요소의 수를 나타냅니다.

  • CounterTimer: (N1 - N0) / (D1 - D0), 여기서 N1 및 N0은 성능 카운터 판독값이고 D1 및 D0은 해당 시간 판독값입니다. 따라서 분자는 모니터링되는 구성 요소가 활성화된 동안 샘플 간격의 부분을 나타내며 분모는 샘플 간격의 총 경과 시간을 나타냅니다.

  • CounterTimerInverse: (1- (N1 - N0) / (D1 - D0)) x 100- 여기서 숫자는 모니터링되는 구성 요소가 비활성 상태인 간격 동안의 시간을 나타내고 분모는 샘플 간격의 총 경과 시간을 나타냅니다.

  • CountPerTimeInterval32: (N1 - N0) / (D1 - D0), 여기서 숫자는 큐의 항목 수를 나타내고 분모는 마지막 샘플 간격 동안 경과된 시간을 나타냅니다.

  • CountPerTimeInterval64: (N1 - N0) / (D1 - D0), 여기서 숫자는 큐의 항목 수를 나타내고 분모는 샘플 간격 동안 경과된 시간을 나타냅니다.

  • ElapsedTime: (D0 - N0) / F입니다. 여기서 D0은 현재 시간을 나타내고 N0은 개체가 시작된 시간을 나타내고 F는 1초 안에 경과하는 시간 단위 수를 나타냅니다. 결과가 초 단위로 표시될 수 있도록 F 값이 수식에 고려됩니다.

  • NumberOfItems32:없음. 평균은 표시하지 않지만 원시 데이터가 수집될 때 표시됩니다.

  • NumberOfItems64:없음. 평균은 표시하지 않지만 원시 데이터가 수집될 때 표시됩니다.

  • NumberOfItemsHEX32:없음. 평균은 표시하지 않지만 원시 데이터가 수집될 때 표시됩니다.

  • NumberOfItemsHEX64:없음. 평균을 표시하지 않지만 수집되는 원시 데이터를 표시합니다.

  • RateOfCountsPerSecond32: (N1 - N0) / ((D1 - D0) / F), 여기서 N1과 N0은 성능 카운터 판독값이고, D1 및 D0은 해당 시간 판독값이며, F는 초당 틱 수를 나타냅니다. 따라서 숫자는 마지막 샘플 간격 동안 수행된 연산의 수를 나타내고, 분모는 마지막 샘플 간격 동안 경과된 틱 수를 나타내고, F는 틱의 빈도입니다. 결과가 초 단위로 표시될 수 있도록 F 값이 수식에 고려됩니다.

  • RateOfCountsPerSecond64: (N1 - N0) / ((D1 - D0) / F), 여기서 N1과 N0은 성능 카운터 판독값이고, D1 및 D0은 해당 시간 판독값이며, F는 초당 틱 수를 나타냅니다. 따라서 숫자는 마지막 샘플 간격 동안 수행된 연산의 수를 나타내고, 분모는 마지막 샘플 간격 동안 경과된 틱 수를 나타내고, F는 틱의 빈도입니다. 결과가 초 단위로 표시될 수 있도록 F 값이 수식에 고려됩니다.

  • RawFraction: (N0/D0) x 100. 여기서 D0은 측정된 특성(형식 RawBase의 기본 카운터 사용)을 나타내고 N0은 해당 특성의 한 구성 요소를 나타냅니다.

  • SampleCounter: (N1 - N0) / ((D1 - D0) / F), 여기서 숫자(N)는 완료된 작업 수를 나타내고, 분모(D)는 시스템 성능 타이머의 틱 단위로 경과된 시간을 나타내고, F는 1초 안에 경과된 틱 수를 나타냅니다. F는 결과를 초 단위로 표시할 수 있도록 수식에 고려됩니다.

  • SampleFraction: ((N1 - N0) / (D1 - D0)) x 100, 여기서 숫자는 마지막 샘플 간격 동안 성공한 작업의 수를 나타내고 분모는 형식 SampleBase의 카운터를 사용하여 샘플 간격 동안 완료된 모든 작업(측정된 형식의) 수의 변경을 나타냅니다.

  • Timer100Ns: (N1 - N0) / (D1 - D0) x 100- 여기서 숫자는 모니터링되는 구성 요소가 활성화된 동안 샘플 간격의 부분을 나타내고 분모는 샘플 간격의 총 경과 시간을 나타냅니다.

  • Timer100NsInverse: (1- (N1 - N0) / (D1 - D0)) x 100- 여기서 숫자는 모니터링되는 구성 요소가 비활성 상태인 간격 동안의 시간을 나타내고 분모는 샘플 간격의 총 경과 시간을 나타냅니다.

예제

다음 예제에서는 열거형의 몇 가지 카운터 형식을 PerformanceCounterType 보여 줍니다.

AverageCount64

using System;
using System.Collections;
using System.Diagnostics;
using System.Runtime.Versioning;

[SupportedOSPlatform("Windows")]
public class App
{
    private static PerformanceCounter avgCounter64Sample;
    private static PerformanceCounter avgCounter64SampleBase;

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

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

    private static bool SetupCategory()
    {
        if (!PerformanceCounterCategory.Exists("AverageCounter64SampleCategory"))
        {
            CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();

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

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

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

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

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

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


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

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

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

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

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

            avgCounter64Sample.IncrementBy(value);

            avgCounter64SampleBase.Increment();

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

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

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

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

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

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

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

<SupportedOSPlatform("Windows")>
Public Class App1

    Private Shared avgCounter64Sample As PerformanceCounter
    Private Shared avgCounter64SampleBase As PerformanceCounter

    Public Shared Sub Main()

        Dim samplesList As New ArrayList()
        'If the category does not exist, create the category and exit.
        'Performance counters should not be created and immediately used.
        'There is a latency time to enable the counters, they should be created
        'prior to executing the App1lication that uses the counters.
        'Execute this sample a second time to use the counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If

    End Sub

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

            Dim counterDataCollection As New CounterCreationDataCollection()

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

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

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

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

    Private Shared Sub CreateCounters()
        ' Create the counters.

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

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

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

    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

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

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

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

            avgCounter64Sample.IncrementBy(value)

            avgCounter64SampleBase.Increment()

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

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

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

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

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

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

AverageTimer32

using System;
using System.Collections;
using System.Diagnostics;
using System.Runtime.Versioning;

[SupportedOSPlatform("Windows")]
public class App2
{
    private static PerformanceCounter PC;
    private static PerformanceCounter BPC;

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

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

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

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

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

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

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

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

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

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

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

        BPC = new PerformanceCounter(categoryName,
            baseCounterName,
            false);

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

    private static void CollectSamples(ArrayList samplesList)
    {

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

        // Loop for the samples.
        for (int i = 0; i < 10; i++)
        {

            PC.RawValue = Stopwatch.GetTimestamp();

            BPC.IncrementBy(10);

            System.Threading.Thread.Sleep(1000);

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

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

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

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

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

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

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

<SupportedOSPlatform("Windows")>
Public Class App

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

    Private Shared PC As PerformanceCounter
    Private Shared BPC As PerformanceCounter


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

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


    Private Shared Function SetupCategory() As Boolean

        If Not PerformanceCounterCategory.Exists(categoryName) Then

            Dim CCDC As New CounterCreationDataCollection()

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

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

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

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

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


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

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

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


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

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

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

            PC.RawValue = Stopwatch.GetTimeStamp()

            BPC.IncrementBy(10)

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


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

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

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

        Next i
    End Sub


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

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

        Return counterValue
    End Function


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


End Class

ElapsedTime


using System;
using System.Diagnostics;
using System.Runtime.Versioning;

[SupportedOSPlatform("Windows")]
public class App
{
    public static void Main()
    {	
        CollectSamples();
    }

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

        // If the category does not exist, create the category and exit.
        // Performance counters should not be created and immediately used.
        // There is a latency time to enable the counters, they should be created
        // prior to executing the application that uses the counters.
        // Execute this sample a second time to use the category.
        if ( !PerformanceCounterCategory.Exists(categoryName) )
        {

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

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

        // Create the performance counter.
        PerformanceCounter PC = new PerformanceCounter(categoryName,
                                                       counterName,
                                                       false);
        // Initialize the counter.
        PC.RawValue = Stopwatch.GetTimestamp();

        DateTime Start = DateTime.Now;

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

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

        Console.WriteLine("Elapsed time = " + DateTime.Now.Subtract(Start).ToString());
    }

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

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

<SupportedOSPlatform("Windows")>
Public Class App2

    Public Shared Sub Main()
        CollectSamples()
    End Sub

    Private Shared Sub CollectSamples()

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

        If Not PerformanceCounterCategory.Exists(categoryName) Then

            Dim CCDC As New CounterCreationDataCollection()

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

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

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

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

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

        Dim Start As DateTime = DateTime.Now

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

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

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


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

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

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

NumberOfItems32

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

public class NumberOfItems64
{

    private static PerformanceCounter PC;

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

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

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

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData NOI64 = new CounterCreationData();
            NOI64.CounterType = PerformanceCounterType.NumberOfItems64;
            NOI64.CounterName = "NumberOfItems32Sample";
            CCDC.Add(NOI64);

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

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

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

        PC.RawValue=0;
    }

    private static void CollectSamples(ArrayList samplesList)
    {

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

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

            PC.IncrementBy(value);

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

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

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

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

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

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

<SupportedOSPlatform("Windows")>
Public Class NumberOfItems64

    Private Shared PC As PerformanceCounter


    Public Shared Sub Main()
        Dim samplesList As New ArrayList()
        'If the category does not exist, create the category and exit.
        'Performance counters should not be created and immediately used.
        'There is a latency time to enable the counters, they should be created
        'prior to executing the application that uses the counters.
        'Execute this sample a second time to use the counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If
    End Sub


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

            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim NOI64 As New CounterCreationData()
            NOI64.CounterType = PerformanceCounterType.NumberOfItems64
            NOI64.CounterName = "NumberOfItems32Sample"
            CCDC.Add(NOI64)

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

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


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

        PC.RawValue = 0
    End Sub


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)



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

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

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

            PC.IncrementBy(value)

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




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

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

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




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


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

NumberOfItems64

using System;
using System.Collections;
using System.Diagnostics;
using System.Runtime.Versioning;

[SupportedOSPlatform("Windows")]
public class NumberOfItems64_1
{
    private static PerformanceCounter PC;

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

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

    private static bool SetupCategory()
    {
        if (!PerformanceCounterCategory.Exists("NumberOfItems64SampleCategory"))
        {
            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData NOI64 = new CounterCreationData();
            NOI64.CounterType = PerformanceCounterType.NumberOfItems64;
            NOI64.CounterName = "NumberOfItems64Sample";
            CCDC.Add(NOI64);

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

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

        PC.RawValue = 0;
    }

    private static void CollectSamples(ArrayList samplesList)
    {
        Random r = new Random(DateTime.Now.Millisecond);

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

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

            PC.IncrementBy(value);

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

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

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

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

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

    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
    {
        Single counterValue = s1.RawValue;
        return (counterValue);
    }

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

<SupportedOSPlatform("Windows")>
Public Class NumberOfItems64_1

    Private Shared PC As PerformanceCounter

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

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

    End Sub


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

            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim NOI64 As New CounterCreationData()
            NOI64.CounterType = PerformanceCounterType.NumberOfItems64
            NOI64.CounterName = "NumberOfItems64Sample"
            CCDC.Add(NOI64)

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

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


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

        PC.RawValue = 0
    End Sub


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

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

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

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

            PC.IncrementBy(value)

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


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

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

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




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


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

SampleFraction

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

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

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

    public static void Main()
    {

        ArrayList samplesList = new ArrayList();

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

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

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

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

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

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

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

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

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

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

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

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

            perfCounter.IncrementBy(thisProcess.UserProcessorTime.Ticks);

            basePerfCounter.IncrementBy(thisProcess.TotalProcessorTime.Ticks);

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

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

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

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

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

    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    // Description - This counter type provides A percentage counter that shows the
    // average ratio of user proccessor time to total processor time  during the last
    // two sample intervals.
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
    {
        Single numerator = (Single)s1.RawValue - (Single)s0.RawValue;
        Single denomenator = (Single)s1.BaseValue - (Single)s0.BaseValue;
        Single counterValue = 100 * (numerator / denomenator);
        return (counterValue);
    }

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


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

<SupportedOSPlatform("Windows")>
Public Class App3

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


    Public Shared Sub Main()

        Dim samplesList As New ArrayList()

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

    End Sub



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

            Dim CCDC As New CounterCreationDataCollection()

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

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

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

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

    End Function 'SetupCategory


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


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


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

    End Sub

    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)


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

            perfCounter.IncrementBy(thisProcess.UserProcessorTime.Ticks)

            basePerfCounter.IncrementBy(thisProcess.TotalProcessorTime.Ticks)

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

    End Sub


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

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

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

    End Sub




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

    End Function 'MyComputeCounterValue


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

    End Sub
End Class

RateOfCountsPerSecond32

using System;
using System.Collections;
using System.Diagnostics;
using System.Runtime.Versioning;

[SupportedOSPlatform("Windows")]
public class App3
{
    private static PerformanceCounter PC;

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

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

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

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData rateOfCounts32 = new CounterCreationData();
            rateOfCounts32.CounterType = PerformanceCounterType.RateOfCountsPerSecond32;
            rateOfCounts32.CounterName = "RateOfCountsPerSecond32Sample";
            CCDC.Add(rateOfCounts32);

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

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

        PC.RawValue = 0;
    }

    private static void CollectSamples(ArrayList samplesList)
    {

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

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

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

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

            if ((j % 10) == 9)
            {
                Console.WriteLine(";       NextValue() = " + PC.NextValue().ToString());
                OutputSample(PC.NextSample());
                samplesList.Add(PC.NextSample());
            }
            else
            {
                Console.WriteLine();
            }

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

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

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

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

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

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

<SupportedOSPlatform("Windows")>
Public Class App4
    Private Shared PC As PerformanceCounter


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

        'If the category does not exist, create the category and exit.
        'Performance counters should not be created and immediately used.
        'There is a latency time to enable the counters, they should be created
        'prior to executing the App4lication that uses the counters.
        'Execute this sample a second time to use the counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If
    End Sub


    Private Shared Function SetupCategory() As Boolean

        If Not PerformanceCounterCategory.Exists("RateOfCountsPerSecond32SampleCategory") Then


            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim rateOfCounts32 As New CounterCreationData()
            rateOfCounts32.CounterType = PerformanceCounterType.RateOfCountsPerSecond32
            rateOfCounts32.CounterName = "RateOfCountsPerSecond32Sample"
            CCDC.Add(rateOfCounts32)

            ' Create the category.
            PerformanceCounterCategory.Create("RateOfCountsPerSecond32SampleCategory", _
                "Demonstrates usage of the RateOfCountsPerSecond32 performance counter type.", _
                PerformanceCounterCategoryType.SingleInstance, CCDC)
            Return True
        Else
            Console.WriteLine("Category exists - RateOfCountsPerSecond32SampleCategory")
            Return False
        End If
    End Function 'SetupCategory


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

        PC.RawValue = 0
    End Sub


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

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

        ' Initialize the performance counter.
        PC.NextSample()

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

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

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


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


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

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





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


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

RateOfCountsPerSecond64

using System;
using System.Collections;
using System.Diagnostics;
using System.Runtime.Versioning;

[SupportedOSPlatform("Windows")]
public class App4
{
    private static PerformanceCounter PC;

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

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

    private static bool SetupCategory()
    {

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

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData rateOfCounts64 = new CounterCreationData();
            rateOfCounts64.CounterType = PerformanceCounterType.RateOfCountsPerSecond64;
            rateOfCounts64.CounterName = "RateOfCountsPerSecond64Sample";
            CCDC.Add(rateOfCounts64);

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

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

        PC.RawValue = 0;
    }

    private static void CollectSamples(ArrayList samplesList)
    {

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

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

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

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

            if ((j % 10) == 9)
            {
                Console.WriteLine(";       NextValue() = " + PC.NextValue().ToString());
                OutputSample(PC.NextSample());
                samplesList.Add(PC.NextSample());
            }
            else
            {
                Console.WriteLine();
            }

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

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

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

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

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

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

<SupportedOSPlatform("Windows")>
Public Class App5
    Private Shared PC As PerformanceCounter


    Public Shared Sub Main()
        Dim samplesList As New ArrayList()
        'If the category does not exist, create the category and exit.
        'Performance counters should not be created and immediately used.
        'There is a latency time to enable the counters, they should be created
        'prior to executing the App5lication that uses the counters.
        'Execute this sample a second time to use the counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If
    End Sub


    Private Shared Function SetupCategory() As Boolean


        If Not PerformanceCounterCategory.Exists("RateOfCountsPerSecond64SampleCategory") Then


            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim rateOfCounts64 As New CounterCreationData()
            rateOfCounts64.CounterType = PerformanceCounterType.RateOfCountsPerSecond64
            rateOfCounts64.CounterName = "RateOfCountsPerSecond64Sample"
            CCDC.Add(rateOfCounts64)

            ' Create the category.
            PerformanceCounterCategory.Create("RateOfCountsPerSecond64SampleCategory", _
            "Demonstrates usage of the RateOfCountsPerSecond64 performance counter type.", _
                PerformanceCounterCategoryType.SingleInstance, CCDC)
            Return True
        Else
            Console.WriteLine("Category exists - RateOfCountsPerSecond64SampleCategory")
            Return False
        End If
    End Function 'SetupCategory


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

        PC.RawValue = 0
    End Sub


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

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

        ' Initialize the performance counter.
        PC.NextSample()

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

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

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


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


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

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




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


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

RawFraction

using System;
using System.Collections;
using System.Diagnostics;
using System.Runtime.Versioning;

[SupportedOSPlatform("Windows")]
public class App5
{
    private static PerformanceCounter PC;
    private static PerformanceCounter BPC;

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

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

    private static bool SetupCategory()
    {

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

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

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

            // Add the base counter.
            CounterCreationData rfBase = new CounterCreationData();
            rfBase.CounterType = PerformanceCounterType.RawBase;
            rfBase.CounterName = "RawFractionSampleBase";
            CCDC.Add(rfBase);

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

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

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

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

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

    private static void CollectSamples(ArrayList samplesList)
    {

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

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

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

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

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

            // Copy out the next value every ten times around the loop.
            if ((j % 10) == 9)
            {
                Console.WriteLine(";       NextValue() = " + PC.NextValue().ToString());
                OutputSample(PC.NextSample());
                samplesList.Add(PC.NextSample());
            }
            else
            {
                Console.WriteLine();
            }

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

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

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

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

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

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

<SupportedOSPlatform("Windows")>
Public Class App6
    Private Shared PC As PerformanceCounter
    Private Shared BPC As PerformanceCounter

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

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

    End Sub

    Private Shared Function SetupCategory() As Boolean


        If Not PerformanceCounterCategory.Exists("RawFractionSampleCategory") Then


            Dim CCDC As New CounterCreationDataCollection()

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

            ' Add the base counter.
            Dim rfBase As New CounterCreationData()
            rfBase.CounterType = PerformanceCounterType.RawBase
            rfBase.CounterName = "RawFractionSampleBase"
            CCDC.Add(rfBase)

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

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


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

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

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


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

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

        ' Initialize the performance counter.
        PC.NextSample()

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

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

            ' Get the % of samples that are 9 or 10 out of all the samples taken.
            If value >= 9 Then
                PC.Increment()
            End If
            ' Copy out the next value every ten times around the loop.
            If j Mod 10 = 9 Then
                Console.WriteLine((";       NextValue() = " + PC.NextValue().ToString()))
                OutputSample(PC.NextSample())
                samplesList.Add(PC.NextSample())
            Else
                Console.WriteLine()
            End If
            System.Threading.Thread.Sleep(50)
        Next j
    End Sub



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

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

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


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


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