dotnetframework/System.Diagnostics.PerformanceCounterv10.0.1
✓ Verified.NET FW4.6.2.NET 10.0.NET 11.0.NET Std2.0
Provides the System.Diagnostics.PerformanceCounter class, which allows access to Windows performance counters. Commonly Used Types: System.Diagnostics.PerformanceCounter
Get Started
$ dotnet add package System.Diagnostics.PerformanceCounterReadme
About
This package provides types that allow applications to interact with the Windows performance counters.
Windows allows you to examine how programs you run affect your computer's performance, both in real time and by collecting log data for later analysis. You can do this via the Windows Performance Monitor tool, which uses performance counters, among other features.
Windows performance counters provide a high-level abstraction layer that provides a consistent interface for collecting various kinds of system data such as CPU, memory, and disk usage. They can be included in the operating system or can be part of individual applications. Windows Performance Monitor requests the current value of performance counters at specifiedtime intervals.
System administrators often use performance counters to monitor systems for performance or behavior problems. Software developers often use performance counters to examine the resource usage of their programs.
Key Features
- Can be used to read existing predefined or custom counters.
- Can be used for publishing (writing) data to custom counters.
- Can collect performance counters from the local machine or from a remote machine.
How to Use
using System;
using System.Collections.Generic;
using System.Diagnostics;
public class App
{
public static void Main()
{
List<CounterSample> samples = [];
// 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;
}
CollectSamples(samples);
CalculateResults(samples);
}
private static bool SetupCategory()
{
if (PerformanceCounterCategory.Exists("AverageCounter64SampleCategory"))
{
Console.WriteLine("Category exists - AverageCounter64SampleCategory");
return false;
}
CounterCreationDataCollection counterDataCollection = [];
// Add the counter.
CounterCreationData averageCount64 = new()
{
CounterType = PerformanceCounterType.AverageCount64,
CounterName = "AverageCounter64Sample"
};
counterDataCollection.Add(averageCount64);
// Add the base counter.
CounterCreationData averageCount64Base = new()
{
CounterType = PerformanceCounterType.AverageBase,
CounterName = "AverageCounter64SampleBase"
};
counterDataCollection.Add(averageCount64Base);
// Create the category.
PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
"Demonstrates usage of the AverageCounter64 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, counterDataCollection);
return true;
}
private static void CollectSamples(List<CounterSample> samples)
{
// Create the counters
PerformanceCounter avgCounter64Sample = new PerformanceCounter("AverageCounter64SampleCategory",
"AverageCounter64Sample",
false)
{
RawValue = 0
};
PerformanceCounter avgCounter64SampleBase = new PerformanceCounter("AverageCounter64SampleCategory",
"AverageCounter64SampleBase",
false)
{
RawValue = 0
};
Random r = new(DateTime.Now.Millisecond);
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());
samples.Add(avgCounter64Sample.NextSample());
}
else
{
Console.WriteLine();
}
System.Threading.Thread.Sleep(50);
}
}
private static void CalculateResults(List<CounterSample> samples)
{
for (int i = 0; i < (samples.Count - 1); i++)
{
// Output the sample.
OutputSample(samples[i]);
OutputSample(samples[i + 1]);
// Use .NET to calculate the counter value.
Console.WriteLine($".NET computed counter value = {CounterSampleCalculator.ComputeCounterValue(samples[i], samples[i + 1])}");
// Calculate the counter value manually.
Console.WriteLine($"My computed counter value = {MyComputeCounterValue(samples[i], samples[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 float MyComputeCounterValue(CounterSample s0, CounterSample s1)
{
float numerator = (float)s1.RawValue - s0.RawValue;
float denomenator = (float)s1.BaseValue - s0.BaseValue;
float 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("++++++++++++++++++++++");
}
}