PerformanceCounter Kelas
Definisi
Penting
Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.
Mewakili komponen penghitung kinerja 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- Warisan
- Penerapan
Contoh
Contoh kode berikut menunjukkan penggunaan PerformanceCounter kelas untuk membuat dan menggunakan jenis penghitung AverageCount64 . Contohnya membuat kategori, menyiapkan penghitung, mengumpulkan data dari penghitung, dan memanggil CounterSampleCalculator kelas untuk menginterpretasikan data penghitung kinerja. Hasil perantara dan akhir ditampilkan di jendela konsol. Untuk contoh tambahan jenis penghitung kinerja lainnya, lihat PerformanceCounterType enumerasi.
#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
Keterangan
Komponen PerformanceCounter dapat digunakan untuk membaca penghitung yang telah ditentukan atau kustom yang ada dan menerbitkan (menulis) data performa ke penghitung kustom.
Ada banyak penghitung yang telah ditentukan sebelumnya yang tercantum dalam kotak dialog Tambahkan Penghitung Monitor Performa Windows. Untuk mempelajari tentang penghitung kinerja .NET Framework, lihat Penghitung Kinerja.
Jenis ini mengimplementasikan IDisposable antarmuka. Ketika Anda telah selesai menggunakan jenis , Anda harus membuangnya baik secara langsung atau tidak langsung. Untuk membuang jenis secara langsung, panggil metodenya Dispose dalam try/catch blok. Untuk membuangnya secara tidak langsung, gunakan konstruksi bahasa seperti using (di C#) atau Using (di Visual Basic). Untuk informasi selengkapnya, lihat bagian "Menggunakan Objek yang Mengimplementasikan IDisposable" di IDisposable topik antarmuka.
Penting
Dalam versi 1.0 dan 1.1 .NET Framework, kelas ini mengharuskan penelepon segera untuk sepenuhnya dipercaya. Dimulai dengan .NET Framework versi 2.0, kelas ini memerlukan PerformanceCounterPermission tindakan tertentu. Sangat disarankan agar PerformanceCounterPermission tidak diberikan ke kode semi-tepercaya. Kemampuan untuk membaca dan menulis penghitung kinerja memungkinkan kode untuk melakukan tindakan seperti menghitung proses yang dijalankan dan mendapatkan informasi tentang mereka.
Selain itu, meneruskan objek ke kode yang PerformanceCounter kurang tepercaya dapat membuat masalah keamanan. Jangan pernah meneruskan objek penghitung kinerja, seperti PerformanceCounterCategory atau PerformanceCounter, ke kode yang kurang tepercaya.
Untuk membaca dari penghitung kinerja, buat instans PerformanceCounter kelas , atur CategoryName, , CounterNamedan, secara opsional, InstanceName atau MachineName properti, lalu panggil NextValue metode untuk mengambil pembacaan penghitung kinerja.
Untuk menerbitkan data penghitung kinerja, buat satu atau beberapa penghitung kustom menggunakan PerformanceCounterCategory.Create metode , buat instans PerformanceCounter kelas , atur CategoryNameproperti , dan CounterName , opsional, InstanceName atau MachineName , lalu panggil IncrementBymetode , Increment, atau Decrement atur RawValue properti untuk mengubah nilai penghitung kustom Anda.
Catatan
Metode Increment, IncrementBy, dan Decrement menggunakan interlock untuk memperbarui nilai penghitung. Ini membantu menjaga nilai penghitung tetap akurat dalam skenario multithreaded atau multiprocess, tetapi juga menghasilkan penalti performa. Jika Anda tidak memerlukan akurasi yang disediakan operasi yang saling mengunci, Anda dapat memperbarui RawValue properti secara langsung hingga 5 kali peningkatan performa. Namun, dalam skenario multithreaded, beberapa pembaruan pada nilai penghitung mungkin diabaikan, yang mengakibatkan data yang tidak akurat.
Penghitung adalah mekanisme pengumpulan data performa. Registri menyimpan nama semua penghitung, yang masing-masing terkait dengan area fungsionalitas sistem tertentu. Contohnya termasuk waktu sibuk prosesor, penggunaan memori, atau jumlah byte yang diterima melalui koneksi jaringan.
Setiap penghitung diidentifikasi secara unik melalui namanya dan lokasinya. Dengan cara yang sama seperti jalur file mencakup drive, direktori, satu atau beberapa subdirektori, dan nama file, informasi penghitung terdiri dari empat elemen: komputer, kategori, instans kategori, dan nama penghitung.
Informasi penghitung harus mencakup kategori, atau objek performa, yang diukur penghitung datanya. Kategori komputer mencakup komponen fisik, seperti prosesor, disk, dan memori. Ada juga kategori sistem, seperti proses dan utas. Setiap kategori terkait dengan elemen fungsi dalam komputer dan memiliki sekumpulan penghitung standar yang ditetapkan untuknya. Objek ini tercantum dalam daftar drop-down Objek performa dari kotak dialog Tambahkan Penghitung dalam Monitor Sistem Windows 2000, dan Anda harus menyertakannya di jalur penghitung. Data performa dikelompokkan menurut kategori yang terkait dengannya.
Dalam kasus tertentu, beberapa salinan dari kategori yang sama dapat ada. Misalnya, beberapa proses dan utas berjalan secara bersamaan, dan beberapa komputer berisi lebih dari satu prosesor. Salinan kategori disebut instans kategori, dan setiap instans memiliki sekumpulan penghitung standar yang ditetapkan untuknya. Jika kategori dapat memiliki lebih dari satu instans, spesifikasi instans harus disertakan dalam informasi penghitung.
Untuk mendapatkan data performa untuk penghitung yang memerlukan nilai awal atau sebelumnya untuk melakukan penghitungan yang diperlukan, panggil NextValue metode dua kali dan gunakan informasi yang dikembalikan sesuai kebutuhan aplikasi Anda.
Catatan
Kategori penghitung kinerja yang diinstal dengan .NET Framework 2.0 menggunakan memori bersama terpisah, dengan setiap kategori penghitung kinerja memiliki memorinya sendiri. Anda dapat menentukan ukuran memori bersama terpisah dengan membuat DWORD bernama FileMappingSize di kunci registri HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<nama> kategori\Performa. Nilai FileMappingSize diatur ke ukuran memori bersama kategori. Ukuran defaultnya adalah 131072 desimal. Jika nilai FileMappingSize tidak ada, fileMappingSize nilai atribut untuk performanceCounters elemen yang ditentukan dalam file Machine.config digunakan, menyebabkan overhead tambahan untuk pemrosesan file konfigurasi. Anda dapat mewujudkan peningkatan performa untuk startup aplikasi dengan mengatur ukuran pemetaan file di registri. Untuk informasi selengkapnya tentang ukuran pemetaan file, lihat <performanceCounters>.
Konstruktor
| PerformanceCounter() |
Menginisialisasi instans PerformanceCounter kelas baca-saja baru, tanpa mengaitkan instans dengan sistem atau penghitung kinerja kustom apa pun. |
| PerformanceCounter(String, String) |
Menginisialisasi instans PerformanceCounter kelas baca-saja baru dan mengaitkannya dengan sistem yang ditentukan atau penghitung kinerja kustom di komputer lokal. Konstruktor ini mengharuskan kategori memiliki satu instans. |
| PerformanceCounter(String, String, Boolean) |
Menginisialisasi instans baru baca-saja atau baca/tulis kelas PerformanceCounter dan mengaitkannya dengan sistem yang ditentukan atau penghitung kinerja kustom di komputer lokal. Konstruktor ini mengharuskan kategori berisi satu instans. |
| PerformanceCounter(String, String, String) |
Menginisialisasi instans PerformanceCounter kelas baca-saja baru dan mengaitkannya dengan sistem yang ditentukan atau penghitung kinerja kustom dan instans kategori di komputer lokal. |
| PerformanceCounter(String, String, String, Boolean) |
Menginisialisasi instans baru, baca-saja atau baca/tulis kelas PerformanceCounter dan mengaitkannya dengan sistem yang ditentukan atau penghitung kinerja kustom dan instans kategori di komputer lokal. |
| PerformanceCounter(String, String, String, String) |
Menginisialisasi instans PerformanceCounter kelas baca-saja baru dan mengaitkannya dengan sistem yang ditentukan atau penghitung kinerja kustom dan instans kategori, pada komputer yang ditentukan. |
Bidang
| DefaultFileMappingSize |
Kedaluwarsa.
Kedaluwarsa.
Kedaluwarsa.
Menentukan ukuran memori global yang dibagikan oleh penghitung performa. Ukuran defaultnya adalah 524.288 byte. |
Properti
| CanRaiseEvents |
Mendapatkan nilai yang menunjukkan apakah komponen dapat menaikkan peristiwa. (Diperoleh dari Component) |
| CategoryName |
Mendapatkan atau menetapkan nama kategori penghitung kinerja untuk penghitung kinerja ini. |
| Container |
IContainer Mendapatkan yang berisi Component. (Diperoleh dari Component) |
| CounterHelp |
Mendapatkan deskripsi untuk penghitung kinerja ini. |
| CounterName |
Mendapatkan atau menetapkan nama penghitung kinerja yang terkait dengan instans ini PerformanceCounter . |
| CounterType |
Mendapatkan jenis penghitung penghitung kinerja terkait. |
| DesignMode |
Mendapatkan nilai yang menunjukkan apakah Component saat ini dalam mode desain. (Diperoleh dari Component) |
| Events |
Mendapatkan daftar penanganan aktivitas yang dilampirkan ke ini Component. (Diperoleh dari Component) |
| InstanceLifetime |
Mendapatkan atau mengatur masa pakai proses. |
| InstanceName |
Mendapatkan atau menetapkan nama instans untuk penghitung kinerja ini. |
| MachineName |
Mendapatkan atau menyetel nama komputer untuk penghitung kinerja ini. |
| RawValue |
Mendapatkan atau menetapkan nilai penghitung ini mentah, atau tidak dihitung. |
| ReadOnly |
Mendapatkan atau menetapkan nilai yang menunjukkan apakah instans ini PerformanceCounter dalam mode baca-saja. |
| Site |
Mendapatkan atau mengatur ISite dari Component. (Diperoleh dari Component) |
Metode
| BeginInit() |
Memulai inisialisasi instans yang PerformanceCounter digunakan pada formulir atau oleh komponen lain. Inisialisasi terjadi pada waktu proses. |
| Close() |
Menutup penghitung kinerja dan membebaskan semua sumber daya yang dialokasikan oleh instans penghitung kinerja ini. |
| CloseSharedResources() |
Membebaskan status bersama pustaka penghitung kinerja yang dialokasikan oleh penghitung. |
| CreateObjRef(Type) |
Membuat objek yang berisi semua informasi relevan yang diperlukan untuk menghasilkan proksi yang digunakan untuk berkomunikasi dengan objek jarak jauh. (Diperoleh dari MarshalByRefObject) |
| Decrement() |
Mengurangi penghitung kinerja terkait satu per satu melalui operasi atom yang efisien. |
| Dispose() |
Merilis semua sumber daya yang Componentdigunakan oleh . (Diperoleh dari Component) |
| Dispose(Boolean) |
Merilis sumber daya tidak terkelola yang digunakan oleh Component dan secara opsional merilis sumber daya terkelola. (Diperoleh dari Component) |
| EndInit() |
Mengakhiri inisialisasi PerformanceCounter instans yang digunakan pada formulir atau oleh komponen lain. Inisialisasi terjadi pada waktu proses. |
| Equals(Object) |
Menentukan apakah objek yang ditentukan sama dengan objek saat ini. (Diperoleh dari Object) |
| GetHashCode() |
Berfungsi sebagai fungsi hash default. (Diperoleh dari Object) |
| GetLifetimeService() |
Kedaluwarsa.
Mengambil objek layanan seumur hidup saat ini yang mengontrol kebijakan seumur hidup untuk instans ini. (Diperoleh dari MarshalByRefObject) |
| GetService(Type) |
Mengembalikan objek yang mewakili layanan yang disediakan oleh Component atau oleh Container. (Diperoleh dari Component) |
| GetType() |
Mendapatkan dari instans Type saat ini. (Diperoleh dari Object) |
| Increment() |
Menaikkan penghitung kinerja terkait satu per satu melalui operasi atom yang efisien. |
| IncrementBy(Int64) |
Kenaikan atau penurunan nilai penghitung kinerja terkait dengan jumlah tertentu melalui operasi atom yang efisien. |
| InitializeLifetimeService() |
Kedaluwarsa.
Mendapatkan objek layanan seumur hidup untuk mengontrol kebijakan seumur hidup untuk instans ini. (Diperoleh dari MarshalByRefObject) |
| MemberwiseClone() |
Membuat salinan dangkal dari saat ini Object. (Diperoleh dari Object) |
| MemberwiseClone(Boolean) |
Membuat salinan dangkal objek saat ini MarshalByRefObject . (Diperoleh dari MarshalByRefObject) |
| NextSample() |
Mendapatkan sampel penghitung, dan mengembalikan nilai mentah, atau tidak dihitung. |
| NextValue() |
Mendapatkan sampel penghitung dan mengembalikan nilai terhitung untuk sampel tersebut. |
| RemoveInstance() |
Menghapus instans kategori yang ditentukan oleh PerformanceCounter properti objek InstanceName . |
| ToString() |
Mengembalikan yang String berisi nama Component, jika ada. Metode ini tidak boleh ditimpa. (Diperoleh dari Component) |
Acara
| Disposed |
Terjadi ketika komponen dibuang oleh panggilan ke Dispose() metode . (Diperoleh dari Component) |
