PerformanceCounterSampleCode.cs

gistfile1.txt

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

public class App
{

    private static PerformanceCounter avgCounter64Sample;
    private static PerformanceCounter avgCounter64SampleBase;
    private static long sampleTimestamp100ns = 0;
    private static int sampleNumber = 1;

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

            CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();

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

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

            // Create the category.
            PerformanceCounterCategory.Create("EFCore6PerformanceCounterCategory",
                "EFCore6 Performance Counter.",
                PerformanceCounterCategoryType.SingleInstance, counterDataCollection);

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

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

        avgCounter64Sample = new PerformanceCounter("EFCore6PerformanceCounterCategory",
            "EFCore6PerformanceCounterSample",
            false);


        avgCounter64SampleBase = new PerformanceCounter("EFCore6PerformanceCounterCategory",
            "EFCore6PerformanceCounterSampleBase",
            false);

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

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

        for (int j = 0; j < 100; j++)
        {
            // call the api

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

            //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("   Number        = " + sampleNumber++);
        Console.WriteLine("   TimeStamp        = " + s.TimeStamp);
        Console.WriteLine("   TimeStamp100nSec = " + s.TimeStamp100nSec);

        double tsDifference = 0;
        if (sampleTimestamp100ns != 0)
            tsDifference = (s.TimeStamp100nSec - sampleTimestamp100ns) / 10000000.0;
        else
            tsDifference = s.TimeStamp100nSec;

        sampleTimestamp100ns = s.TimeStamp100nSec;

        Console.WriteLine("Timestamp difference (seconds) = " + tsDifference);
        Console.WriteLine("++++++++++++++++++++++");
    }
}