PerformanceCounter Класс
Определение
Важно!
Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.
Представляет компонент счетчика производительности Windows NT.
public ref class PerformanceCounter sealed : System::ComponentModel::Component, System::ComponentModel::ISupportInitializepublic sealed class PerformanceCounter : System.ComponentModel.Component, System.ComponentModel.ISupportInitializetype PerformanceCounter = class
inherit Component
interface ISupportInitializePublic NotInheritable Class PerformanceCounter
Inherits Component
Implements ISupportInitialize- Наследование
- Реализации
Примеры
В следующем примере кода показано использование класса для PerformanceCounter создания и использования типа счетчика AverageCount64 . В примере создаются категории, настраивается счетчики, собираются данные из счетчиков и вызывается CounterSampleCalculator класс для интерпретации данных счетчика производительности. Промежуточные и окончательные результаты отображаются в окне консоли. Дополнительные примеры других типов счетчиков производительности см. в перечислении PerformanceCounterType .
#using <System.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
// Output information about the counter sample.
void OutputSample( CounterSample s )
{
Console::WriteLine( "\r\n+++++++++++" );
Console::WriteLine( "Sample values - \r\n" );
Console::WriteLine( " BaseValue = {0}", s.BaseValue );
Console::WriteLine( " CounterFrequency = {0}", s.CounterFrequency );
Console::WriteLine( " CounterTimeStamp = {0}", s.CounterTimeStamp );
Console::WriteLine( " CounterType = {0}", s.CounterType );
Console::WriteLine( " RawValue = {0}", s.RawValue );
Console::WriteLine( " SystemFrequency = {0}", s.SystemFrequency );
Console::WriteLine( " TimeStamp = {0}", s.TimeStamp );
Console::WriteLine( " TimeStamp100nSec = {0}", s.TimeStamp100nSec );
Console::WriteLine( "++++++++++++++++++++++" );
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// Description - This counter type shows how many items are processed, on average,
// during an operation. Counters of this type display a ratio of the items
// processed (such as bytes sent) to the number of operations completed. The
// ratio is calculated by comparing the number of items processed during the
// last interval to the number of operations completed during the last interval.
// Generic type - Average
// Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number
// of items processed during the last sample interval and the denominator (D)
// represents the number of operations completed during the last two sample
// intervals.
// Average (Nx - N0) / (Dx - D0)
// Example PhysicalDisk\ Avg. Disk Bytes/Transfer
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
float MyComputeCounterValue( CounterSample s0, CounterSample s1 )
{
float numerator = (float)s1.RawValue - (float)s0.RawValue;
float denomenator = (float)s1.BaseValue - (float)s0.BaseValue;
float counterValue = numerator / denomenator;
return counterValue;
}
bool SetupCategory()
{
if ( !PerformanceCounterCategory::Exists( "AverageCounter64SampleCategory" ) )
{
CounterCreationDataCollection^ CCDC = gcnew CounterCreationDataCollection;
// Add the counter.
CounterCreationData^ averageCount64 = gcnew CounterCreationData;
averageCount64->CounterType = PerformanceCounterType::AverageCount64;
averageCount64->CounterName = "AverageCounter64Sample";
CCDC->Add( averageCount64 );
// Add the base counter.
CounterCreationData^ averageCount64Base = gcnew CounterCreationData;
averageCount64Base->CounterType = PerformanceCounterType::AverageBase;
averageCount64Base->CounterName = "AverageCounter64SampleBase";
CCDC->Add( averageCount64Base );
// Create the category.
PerformanceCounterCategory::Create( "AverageCounter64SampleCategory", "Demonstrates usage of the AverageCounter64 performance counter type.", CCDC );
return (true);
}
else
{
Console::WriteLine( "Category exists - AverageCounter64SampleCategory" );
return (false);
}
}
void CreateCounters( PerformanceCounter^% PC, PerformanceCounter^% BPC )
{
// Create the counters.
PC = gcnew PerformanceCounter( "AverageCounter64SampleCategory","AverageCounter64Sample",false );
BPC = gcnew PerformanceCounter( "AverageCounter64SampleCategory","AverageCounter64SampleBase",false );
PC->RawValue = 0;
BPC->RawValue = 0;
}
void CollectSamples( ArrayList^ samplesList, PerformanceCounter^ PC, PerformanceCounter^ BPC )
{
Random^ r = gcnew Random( DateTime::Now.Millisecond );
// Loop for the samples.
for ( int j = 0; j < 100; j++ )
{
int value = r->Next( 1, 10 );
Console::Write( "{0} = {1}", j, value );
PC->IncrementBy( value );
BPC->Increment();
if ( (j % 10) == 9 )
{
OutputSample( PC->NextSample() );
samplesList->Add( PC->NextSample() );
}
else
Console::WriteLine();
System::Threading::Thread::Sleep( 50 );
}
}
void CalculateResults( ArrayList^ samplesList )
{
for ( int i = 0; i < (samplesList->Count - 1); i++ )
{
// Output the sample.
OutputSample( *safe_cast<CounterSample^>(samplesList[ i ]) );
OutputSample( *safe_cast<CounterSample^>(samplesList[ i + 1 ]) );
// Use .NET to calculate the counter value.
Console::WriteLine( ".NET computed counter value = {0}", CounterSampleCalculator::ComputeCounterValue( *safe_cast<CounterSample^>(samplesList[ i ]), *safe_cast<CounterSample^>(samplesList[ i + 1 ]) ) );
// Calculate the counter value manually.
Console::WriteLine( "My computed counter value = {0}", MyComputeCounterValue( *safe_cast<CounterSample^>(samplesList[ i ]), *safe_cast<CounterSample^>(samplesList[ i + 1 ]) ) );
}
}
int main()
{
ArrayList^ samplesList = gcnew ArrayList;
PerformanceCounter^ PC;
PerformanceCounter^ BPC;
SetupCategory();
CreateCounters( PC, BPC );
CollectSamples( samplesList, PC, BPC );
CalculateResults( samplesList );
}
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 класса , задайте CategoryNameсвойства , CounterNameи ( при необходимости) InstanceName или MachineName , а затем вызовите NextValue метод для чтения счетчика производительности.
Чтобы опубликовать данные счетчика производительности, создайте один или несколько настраиваемых счетчиков с помощью PerformanceCounterCategory.Create метода , создайте экземпляр PerformanceCounter класса , задайте CategoryNameсвойства , CounterName и ( при необходимости) InstanceName или MachineName , а затем вызовите IncrementByметоды , Incrementили Decrement задайте RawValue свойство , чтобы изменить значение настраиваемого счетчика.
Примечание
Методы Increment, IncrementByи Decrement используют блокировки для обновления значения счетчика. Это помогает сохранить точное значение счетчика в многопоточных или многопроцессных сценариях, но также приводит к снижения производительности. Если точность, обеспечиваемая операциями с блокировкой, не требуется, можно обновить RawValue свойство напрямую, чтобы повысить производительность в 5 раз. Однако в многопоточных сценариях некоторые обновления значения счетчика могут игнорироваться, что приводит к неточным данным.
Счетчик — это механизм сбора данных о производительности. В реестре хранятся имена всех счетчиков, каждый из которых связан с определенной областью функциональности системы. Примеры включают время загрузки процессора, использование памяти или количество байтов, полученных через сетевое подключение.
Каждый счетчик однозначно идентифицируется по имени и расположению. Точно так же, как путь к файлу включает диск, каталог, один или несколько подкаталогов и имя файла, сведения о счетчике состоят из четырех элементов: компьютера, категории, экземпляра категории и имени счетчика.
Сведения о счетчике должны включать категорию или объект производительности, для которых счетчик измеряет данные. Категории компьютеров включают физические компоненты, такие как процессоры, диски и память. Существуют также системные категории, такие как процессы и потоки. Каждая категория связана с функциональным элементом на компьютере и ей назначен набор стандартных счетчиков. Эти объекты перечислены в раскрывающемся списке Объект производительности диалогового окна Добавление счетчиков в системном мониторе Windows 2000, и их необходимо включить в путь счетчика. Данные о производительности группируются по категории, с которой они связаны.
В некоторых случаях может существовать несколько копий одной и той же категории. Например, несколько процессов и потоков выполняются одновременно, а некоторые компьютеры содержат несколько процессоров. Копии категорий называются экземплярами категорий, и каждому экземпляру назначен набор стандартных счетчиков. Если категория может содержать несколько экземпляров, спецификация экземпляра должна быть включена в сведения счетчика.
Чтобы получить данные о производительности для счетчиков, которым требовалось начальное или предыдущее значение для выполнения необходимых вычислений, вызовите NextValue метод дважды и используйте возвращаемые сведения в соответствии с требованиями приложения.
Примечание
Категории счетчиков производительности, установленные вместе с платформа .NET Framework 2.0, используют отдельную общую память, при этом каждая категория счетчиков производительности имеет собственную память. Вы можете указать размер отдельной общей памяти, создав DWORD с именем FileMappingSize в разделе реестра HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<имя> категории\Производительность. Для параметра FileMappingSize задается размер общей памяти категории. Размер по умолчанию — 131072 десятичное число. Если значение FileMappingSize отсутствует, fileMappingSize используется значение атрибута для performanceCounters элемента, указанного в файле Machine.config, что приводит к дополнительным издержкам при обработке файла конфигурации. Вы можете повысить производительность при запуске приложения, задав размер сопоставления файлов в реестре. Дополнительные сведения о размере сопоставления файлов см. в разделе <performanceCounters>.
Конструкторы
| PerformanceCounter() |
Выполняет инициализацию нового, доступного только для чтения экземпляра класса PerformanceCounter, не связывая этот экземпляр с каким-нибудь системным или определенным пользователем счетчиком производительности. |
| PerformanceCounter(String, String) |
Выполняет инициализацию нового, доступного только для чтения экземпляра класса PerformanceCounter и связывает этот экземпляр с конкретным системным или определенным пользователем счетчиком производительности на локальном компьютере. Этот конструктор требует, чтобы категория имела единственный экземпляр. |
| PerformanceCounter(String, String, Boolean) |
Выполняет инициализацию нового, доступного только для чтения или для чтения и записи экземпляра класса PerformanceCounter и связывает этот экземпляр с конкретным системным или определенным пользователем счетчиком производительности на локальном компьютере. Этот конструктор требует, чтобы категория содержала единственный экземпляр. |
| PerformanceCounter(String, String, String) |
Выполняет инициализацию нового, доступного только для чтения экземпляра класса PerformanceCounter и связывает этот экземпляр с конкретным системным или определенным пользователем счетчиком производительности и экземпляром категории на локальном компьютере. |
| PerformanceCounter(String, String, String, Boolean) |
Выполняет инициализацию нового, доступного только для чтения или для чтения и записи экземпляра класса PerformanceCounter и связывает этот экземпляр с конкретным системным или определенным пользователем счетчиком производительности и экземпляром категории на локальном компьютере. |
| PerformanceCounter(String, String, String, String) |
Выполняет инициализацию нового, доступного только для чтения экземпляра класса PerformanceCounter и связывает этот экземпляр с конкретным системным или определенным пользователем счетчиком производительности на указанном компьютере. |
Поля
| DefaultFileMappingSize |
Устаревшие..
Устаревшие..
Устаревшие..
Он указывает размер глобальной памяти в байтах, используемой счетчиками производительности. Размер по умолчанию равен 524,288 байт. |
Свойства
| CanRaiseEvents |
Возвращает значение, показывающее, может ли компонент вызывать событие. (Унаследовано от Component) |
| CategoryName |
Получает или задает имя категории счетчика производительности для этого счетчика производительности. |
| Container |
Возвращает объект IContainer, который содержит коллекцию Component. (Унаследовано от Component) |
| CounterHelp |
Получает описание для этого счетчика производительности. |
| CounterName |
Получает или задает имя категории счетчика производительности, связанного с данным экземпляром PerformanceCounter. |
| CounterType |
Получает тип счетчика, с которым связан счетчик производительности. |
| DesignMode |
Возвращает значение, указывающее, находится ли данный компонент Component в режиме конструктора в настоящее время. (Унаследовано от Component) |
| Events |
Возвращает список обработчиков событий, которые прикреплены к этому объекту Component. (Унаследовано от Component) |
| InstanceLifetime |
Получает или задает время существования процесса. |
| InstanceName |
Получает или задает имя экземпляра для этого счетчика производительности. |
| MachineName |
Возвращает или задает имя компьютера для этого счетчика производительности. |
| RawValue |
Получает или задает начальное или не рассчитанное значение этого счетчика. |
| ReadOnly |
Получает или задает значение, определяющее, доступен ли экземпляр PerformanceCounter только для чтения. |
| Site |
Получает или задает ISite объекта Component. (Унаследовано от Component) |
Методы
| BeginInit() |
Начинает инициализацию экземпляра PerformanceCounter, используемого в форме или другим компонентом. Инициализация происходит во время выполнения. |
| Close() |
Закрывает счетчик производительности и высвобождает все ресурсы, распределенные под этот экземпляр счетчика производительности. |
| CloseSharedResources() |
Высвобождает разделенное состояние библиотеки счетчика производительности, распределенное под счетчики. |
| CreateObjRef(Type) |
Создает объект, который содержит всю необходимую информацию для создания прокси-сервера, используемого для взаимодействия с удаленным объектом. (Унаследовано от MarshalByRefObject) |
| Decrement() |
Уменьшает значение связанного счетчика производительности на единицу через эффективные атомарные операции. |
| Dispose() |
Освобождает все ресурсы, занятые модулем Component. (Унаследовано от Component) |
| Dispose(Boolean) |
Освобождает неуправляемые ресурсы, используемые объектом Component, а при необходимости освобождает также управляемые ресурсы. (Унаследовано от Component) |
| EndInit() |
Завершает инициализацию экземпляра PerformanceCounter, используемого в форме или другим компонентом. Инициализация происходит во время выполнения. |
| Equals(Object) |
Определяет, равен ли указанный объект текущему объекту. (Унаследовано от Object) |
| GetHashCode() |
Служит хэш-функцией по умолчанию. (Унаследовано от Object) |
| GetLifetimeService() |
Устаревшие..
Извлекает объект обслуживания во время существования, который управляет политикой времени существования данного экземпляра. (Унаследовано от MarshalByRefObject) |
| GetService(Type) |
Возвращает объект, представляющий службу, предоставляемую классом Component или классом Container. (Унаследовано от Component) |
| GetType() |
Возвращает объект Type для текущего экземпляра. (Унаследовано от Object) |
| Increment() |
Увеличивает значение связанного счетчика производительности на единицу через эффективные атомарные операции. |
| IncrementBy(Int64) |
Увеличивает или уменьшает значение связанного счетчика производительности на заданное значение посредством эффективных атомарных операций. |
| InitializeLifetimeService() |
Устаревшие..
Получает объект службы времени существования для управления политикой времени существования для этого экземпляра. (Унаследовано от MarshalByRefObject) |
| MemberwiseClone() |
Создает неполную копию текущего объекта Object. (Унаследовано от Object) |
| MemberwiseClone(Boolean) |
Создает неполную копию текущего объекта MarshalByRefObject. (Унаследовано от MarshalByRefObject) |
| NextSample() |
Получает образец счетчика и возвращает начальное или не рассчитанное значение для него. |
| NextValue() |
Получает образец счетчика и возвращает расчетное значение для него. |
| RemoveInstance() |
Удаляет экземпляр категории, указанной объектом PerformanceCounter свойства InstanceName. |
| ToString() |
Возвращает объект String, содержащий имя Component, если оно есть. Этот метод не следует переопределять. (Унаследовано от Component) |
События
| Disposed |
Возникает при удалении компонента путем вызова метода Dispose(). (Унаследовано от Component) |
Применяется к
См. также раздел
Обратная связь
Ожидается в ближайшее время: в течение 2024 года мы постепенно откажемся от GitHub Issues как механизма обратной связи для контента и заменим его новой системой обратной связи. Дополнительные сведения см. в разделе https://aka.ms/ContentUserFeedback.
Отправить и просмотреть отзыв по