PerformanceCounter Класс

Определение

Пространство имен:

System.Diagnostics

Сборка:

System.Diagnostics.PerformanceCounter.dll

Исходный код:

PerformanceCounter.cs

Представляет компонент счетчика производительности Windows NT.

public ref class PerformanceCounter sealed : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize

public sealed class PerformanceCounter : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type PerformanceCounter = class
    inherit Component
    interface ISupportInitialize

Public NotInheritable Class PerformanceCounter
Inherits Component
Implements ISupportInitialize

Наследование

Object

MarshalByRefObject

Component

PerformanceCounter

Реализации

ISupportInitialize

Примеры

В следующем примере кода показано использование PerformanceCounter класса для создания и использования типа счетчика AverageCount64 . В примере создаются категории, настраивается счетчики, собираются данные из счетчиков и вызывается CounterSampleCalculator класс для интерпретации данных счетчика производительности. Промежуточные и окончательные результаты отображаются в окне консоли. Дополнительные примеры других типов счетчиков производительности см. в PerformanceCounterType перечислении.

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

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

 _

Public Class App

    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 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("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

Комментарии

Компонент PerformanceCounter можно использовать как для чтения существующих предопределенных счетчиков, так и для публикации (записи) данных о производительности в настраиваемые счетчики.

В диалоговом окне "Добавление счетчиков производительности Windows" перечислены многочисленные предопределенные счетчики. Дополнительные сведения о счетчиках производительности .NET Framework см. в статье "Счетчики производительности".

Этот тип реализует IDisposable интерфейс. Завершив использование типа, следует избавиться от него напрямую или косвенно. Чтобы удалить тип напрямую, вызовите его Dispose метод в блоке try/catch . Чтобы удалить его косвенно, используйте конструкцию языка, например using (в C#) или Using (в Visual Basic). Дополнительные сведения см. в разделе "Использование объекта, реализующего IDisposable" в IDisposable разделе интерфейса.

Это важно

В версиях 1.0 и 1.1 .NET Framework этот класс требует немедленного доверия вызывающих объектов. Начиная с .NET Framework версии 2.0, этот класс требует PerformanceCounterPermission для определенных действий. Настоятельно рекомендуется PerformanceCounterPermission не предоставлять полунадежный код. Возможность чтения и записи счетчиков производительности позволяет коду выполнять такие действия, как перечисление процессов и получение сведений о них.

Кроме того, передача объекта в менее доверенный PerformanceCounter код может создать проблему безопасности. Никогда не передают объекты счетчика производительности, такие как PerformanceCounterCategory или PerformanceCounterменее доверенный код.

Чтобы считывать данные из счетчика PerformanceCounter производительности, создайте экземпляр класса, задайте CounterNameCategoryNameзначение и, при необходимости, InstanceName свойства или MachineName свойства, а затем вызовите NextValue метод для чтения счетчика производительности.

Чтобы опубликовать данные счетчика производительности, создайте один или несколько настраиваемых счетчиков с помощью PerformanceCounterCategory.Create метода, создайте экземпляр PerformanceCounter класса, задайте CounterNameCategoryNameзначение и, при необходимости, InstanceName или MachineName свойства, а затем вызовите IncrementIncrementByDecrement методы, или задайте RawValue свойство, чтобы изменить значение настраиваемого счетчика.

Замечание

IncrementByМетоды Incrementи Decrement методы используют взаимоблокировки для обновления значения счетчика. Это помогает обеспечить точность счетчика в многопоточных или многопроцессных сценариях, но также приводит к штрафу производительности. Если вам не нужна точность, которая обеспечивает заблокированные операции, можно обновить RawValue свойство непосредственно до 5 раз. Однако в многопоточных сценариях некоторые обновления значения счетчика могут игнорироваться, что приводит к неточным данным.

Счетчик — это механизм сбора данных о производительности. В реестре хранятся имена всех счетчиков, каждая из которых связана с определенной областью функций системы. Примеры включают время занятого процессора, использование памяти или количество байтов, полученных через сетевое подключение.

Каждый счетчик однозначно определяется по имени и его расположению. Таким же образом, как путь к файлу содержит диск, каталог, одну или несколько подкаталогов и имя файла, сведения о счетчике состоят из четырех элементов: компьютера, категории, экземпляра категории и имени счетчика.

Сведения о счетчике должны содержать категорию или объект производительности, для которых счетчик измеряет данные. Категории компьютера включают физические компоненты, такие как процессоры, диски и память. Существуют также системные категории, такие как процессы и потоки. Каждая категория связана с функциональным элементом на компьютере и имеет набор стандартных счетчиков, назначенных ему. Эти объекты перечислены в раскрывающемся списке "Производительность" диалогового окна "Добавление счетчиков" в системном мониторе Windows 2000, и их необходимо включить в путь счетчика. Данные о производительности группируются по категории, к которой она связана.

В некоторых случаях может существовать несколько копий одной категории. Например, несколько процессов и потоков выполняются одновременно, а некоторые компьютеры содержат несколько процессоров. Копии категорий называются экземплярами категорий, и каждый экземпляр имеет набор стандартных счетчиков, назначенных ему. Если категория может иметь несколько экземпляров, спецификация экземпляра должна быть включена в сведения о счетчике.

Чтобы получить данные о производительности для счетчиков, требующих начального или предыдущего значения для выполнения необходимых вычислений, вызовите NextValue метод дважды и используйте сведения, возвращаемые в соответствии с требованиями приложения.

Замечание

Категории счетчиков производительности, установленные с помощью .NET, используют отдельную общую память, при этом каждая категория счетчиков производительности имеет собственную память. Размер отдельной общей памяти можно указать, создав DWORD с именем FileMappingSize в разделе реестра HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<имени> категории\Performance. Значение FileMappingSize имеет общий размер памяти категории. Размер по умолчанию — 131072 десятичное значение. Если значение FileMappingSize отсутствует, используется значение атрибута для элемента, fileMappingSize указанного performanceCounters в файле Machine.config, что приводит к дополнительным затратам на обработку файлов конфигурации. Вы можете реализовать улучшение производительности запуска приложения, задав размер сопоставления файлов в реестре. Дополнительные сведения о размере сопоставления файлов см. в разделе <PerformanceCounters>.

Конструкторы

Имя	Описание
PerformanceCounter()	Инициализирует новый экземпляр класса, доступный только для чтения, без связывания экземпляра PerformanceCounter с любым системным или пользовательским счетчиком производительности.
PerformanceCounter(String, String, Boolean)	Инициализирует новый экземпляр PerformanceCounter класса только для чтения или записи и связывает его с указанным системным или пользовательским счетчиком производительности на локальном компьютере. Для этого конструктора требуется, чтобы категория содержала один экземпляр.
PerformanceCounter(String, String, String, Boolean)	Инициализирует новый экземпляр PerformanceCounter класса только для чтения или записи и связывает его с указанным системным или пользовательским экземпляром счетчика производительности и категории на локальном компьютере.
PerformanceCounter(String, String, String, String)	Инициализирует новый экземпляр класса только PerformanceCounter для чтения и связывает его с указанным системным или пользовательским экземпляром счетчика производительности и экземпляра категории на указанном компьютере.
PerformanceCounter(String, String, String)	Инициализирует новый экземпляр класса только для PerformanceCounter чтения и связывает его с указанным системным или пользовательским экземпляром счетчика производительности и экземпляром категории на локальном компьютере.
PerformanceCounter(String, String)	Инициализирует новый экземпляр класса только для PerformanceCounter чтения и связывает его с указанным системным или пользовательским счетчиком производительности на локальном компьютере. Для этого конструктора требуется, чтобы в категории был один экземпляр.

Поля

Имя	Описание
DefaultFileMappingSize	Устаревшие.. Задает размер глобальной памяти, к которой используется счетчики производительности, в байтах. Размер по умолчанию — 524 288 байт.

Свойства

Имя	Описание
CategoryName	Возвращает или задает имя категории счетчика производительности для этого счетчика производительности.
CounterHelp	Возвращает описание этого счетчика производительности.
CounterName	Возвращает или задает имя счетчика производительности, связанного с этим PerformanceCounter экземпляром.
CounterType	Возвращает тип счетчика связанного счетчика производительности.
InstanceLifetime	Возвращает или задает время существования процесса.
InstanceName	Возвращает или задает имя экземпляра для этого счетчика производительности.
MachineName	Возвращает или задает имя компьютера для этого счетчика производительности.
RawValue	Возвращает или задает необработанное или нерасчисленное значение этого счетчика.
ReadOnly	Возвращает или задает значение, указывающее, находится ли этот PerformanceCounter экземпляр в режиме только для чтения.

Методы

Имя	Описание
BeginInit()	Начинает инициализацию экземпляра, PerformanceCounter используемого в форме или другом компоненте. Инициализация происходит во время выполнения.
Close()	Закрывает счетчик производительности и освобождает все ресурсы, выделенные этим экземпляром счетчика производительности.
CloseSharedResources()	Освобождает общую библиотеку счетчиков производительности, выделенную счетчиками.
Decrement()	Уменьшает связанный счетчик производительности по одному через эффективную атомарную операцию.
EndInit()	Завершает инициализацию экземпляра, используемого PerformanceCounter в форме или другом компоненте. Инициализация происходит во время выполнения.
Increment()	Увеличивает связанный счетчик производительности по одному через эффективную атомарную операцию.
IncrementBy(Int64)	Увеличивает или уменьшает значение связанного счетчика производительности по заданному количеству с помощью эффективной атомарной операции.
NextSample()	Получает пример счетчика и возвращает необработанное или нерасчисленное значение для него.
NextValue()	Получает пример счетчика и возвращает вычисляемое значение.
RemoveInstance()	Удаляет экземпляр категории, указанный свойством PerformanceCounter объекта InstanceName .

См. также раздел

• PerformanceCounterType
• CounterCreationData
• CounterCreationDataCollection
• CounterSample
• CounterSampleCalculator