PerformanceCounter Třída
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Představuje systém Windows NT součást čítače výkonu.
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- Dědičnost
- Implementuje
Příklady
Následující příklad kódu ukazuje použití PerformanceCounter třídy k vytvoření a použití typu čítače AverageCount64 . Příklad vytvoří kategorie, nastaví čítače, shromažďuje data z čítačů a volá CounterSampleCalculator třídu k interpretaci dat čítačů výkonu. V okně konzoly se zobrazí průběžné a konečné výsledky. Další příklady jiných typů čítačů výkonu najdete ve výčtu 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
Poznámky
Komponentu PerformanceCounter lze použít ke čtení existujících předdefinovaných nebo vlastních čítačů a k publikování (zápisu) dat o výkonu do vlastních čítačů.
V dialogovém okně Přidat čítače windows Sledování výkonu je uvedeno mnoho předdefinovaných čítačů. Další informace o čítačích výkonu rozhraní .NET Framework najdete v tématu Čítače výkonu.
Tento typ implementuje IDisposable rozhraní. Po dokončení používání tohoto typu byste ho měli přímo nebo nepřímo odstranit. Pokud chcete odstranit typ přímo, zavolejte jeho Dispose metodu try/catch v bloku. Pokud ho chcete odstranit nepřímo, použijte konstruktor jazyka, například using (v jazyce C#) nebo Using (v jazyce Visual Basic). Další informace najdete v části "Použití objektu, který implementuje IDisposable" v IDisposable tématu rozhraní.
Důležité
Ve verzích 1.0 a 1.1 rozhraní .NET Framework tato třída vyžaduje, aby se okamžitě volající plně důvěřovali. Počínaje rozhraním .NET Framework verze 2.0 vyžaduje PerformanceCounterPermission tato třída konkrétní akce. Důrazně doporučujeme neudělovat PerformanceCounterPermission částečně důvěryhodný kód. Schopnost číst a zapisovat čítače výkonu umožňuje kódu provádět akce, jako je výčet spouštění procesů a získání informací o nich.
Kromě toho může předání objektu PerformanceCounter méně důvěryhodnému kódu vytvořit problém se zabezpečením. Nikdy nepředávejte objekty čítačů výkonu PerformanceCounterCategory , například nebo PerformanceCounter, do méně důvěryhodného kódu.
Chcete-li číst z čítače výkonu PerformanceCounter , vytvořte instanci třídy, nastavte CategoryNamevlastnosti , CounterNamea volitelně InstanceName vlastnosti nebo MachineName a pak zavolejte metodu NextValue pro čtení čítače výkonu.
Chcete-li publikovat data čítačů výkonu, vytvořte jeden nebo více vlastních čítačů pomocí PerformanceCounterCategory.Create metody, vytvořte instanci PerformanceCounter třídy, nastavte CategoryNamevlastnosti a CounterName , volitelně InstanceName nebo nebo MachineName a pak volejte IncrementBymetody , Incrementnebo Decrement nebo nastavte RawValue vlastnost pro změnu hodnoty vlastního čítače.
Poznámka
Metody Increment, IncrementBya Decrement používají vzájemné uzamčení k aktualizaci hodnoty čítače. To pomáhá udržovat hodnotu čítače přesnou ve vícevláknových nebo víceprocesových scénářích, ale také má za následek penalizaci výkonu. Pokud nepotřebujete přesnost, kterou poskytují vzájemně propojené operace, můžete vlastnost aktualizovat RawValue přímo pro až 5krát vyšší výkon. Ve scénářích s více vlákny však mohou být některé aktualizace hodnoty čítače ignorovány, což vede k nepřesným datům.
Čítač je mechanismus, kterým se shromažďují data o výkonu. V registru se ukládají názvy všech čítačů, z nichž každý souvisí s určitou oblastí funkčnosti systému. Mezi příklady patří zaneprázdněný čas procesoru, využití paměti nebo počet bajtů přijatých přes síťové připojení.
Každý čítač je jedinečně identifikován svým názvem a umístěním. Stejně jako cesta k souboru obsahuje jednotku, adresář, jeden nebo více podadresářů a název souboru, informace o čítači se skládají ze čtyř prvků: počítače, kategorie, instance kategorie a názvu čítače.
Informace o čítači musí obsahovat kategorii neboli objekt výkonu, pro který čítač měří data. Kategorie počítače zahrnují fyzické komponenty, jako jsou procesory, disky a paměť. Existují také systémové kategorie, jako jsou procesy a vlákna. Každá kategorie souvisí s funkčním prvkem v počítači a má přiřazenou sadu standardních čítačů. Tyto objekty jsou uvedeny v rozevíracím seznamu Objekt výkonu v dialogovém okně Přidat čítače v nástroji Sledování systému Windows 2000 a musíte je zahrnout do cesty čítače. Údaje o výkonu jsou seskupené podle kategorie, se kterou souvisí.
V některých případech může existovat několik kopií stejné kategorie. Například několik procesů a vláken běží současně a některé počítače obsahují více než jeden procesor. Kopie kategorií se nazývají instance kategorií a každá instance má přiřazenou sadu standardních čítačů. Pokud kategorie může mít více než jednu instanci, musí být v informacích o čítači zahrnuta specifikace instance.
Pokud chcete získat data o výkonu pro čítače, které pro provedení potřebného výpočtu vyžadovaly počáteční nebo předchozí hodnotu, zavolejte metodu NextValue dvakrát a použijte informace, které se vrátí podle potřeby vaší aplikace.
Poznámka
Kategorie čítačů výkonu nainstalované s rozhraním .NET Framework 2.0 používají samostatnou sdílenou paměť, přičemž každá kategorie čítačů výkonu má vlastní paměť. Velikost samostatné sdílené paměti můžete určit vytvořením hodnoty DWORD s názvem FileMappingSize v klíči registru HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<název> kategorie\Výkon. Hodnota FileMappingSize je nastavená na velikost sdílené paměti kategorie. Výchozí velikost je 131072 desetinných míst. Pokud hodnota FileMappingSize neexistuje, fileMappingSize použije se hodnota atributu elementu performanceCounters zadaného v souboru Machine.config, což způsobí další režii při zpracování konfiguračního souboru. Zvýšení výkonu při spouštění aplikace můžete dosáhnout nastavením velikosti mapování souborů v registru. Další informace o velikosti mapování souborů najdete v tématu <performanceCounters>.
Konstruktory
| PerformanceCounter() |
Inicializuje novou instanci PerformanceCounter třídy jen pro čtení bez přidružení instance k jakémukoli systémovému nebo vlastnímu čítači výkonu. |
| PerformanceCounter(String, String) |
Inicializuje novou instanci třídy jen pro čtení a přidruží PerformanceCounter ji k zadanému systému nebo vlastnímu čítači výkonu v místním počítači. Tento konstruktor vyžaduje, aby kategorie měla jednu instanci. |
| PerformanceCounter(String, String, Boolean) |
Inicializuje novou instanci PerformanceCounter třídy, jen pro čtení nebo pro čtení/zápis a přidruží ji k zadanému systémovému nebo vlastnímu čítači výkonu v místním počítači. Tento konstruktor vyžaduje, aby kategorie obsahovala jednu instanci. |
| PerformanceCounter(String, String, String) |
Inicializuje novou instanci PerformanceCounter třídy jen pro čtení a přidruží ji k zadanému systémovému nebo vlastnímu čítači výkonu a instanci kategorie v místním počítači. |
| PerformanceCounter(String, String, String, Boolean) |
Inicializuje novou instanci PerformanceCounter třídy, jen pro čtení nebo pro čtení/zápis a přidruží ji k zadanému systémovému nebo vlastnímu čítači výkonu a instanci kategorie v místním počítači. |
| PerformanceCounter(String, String, String, String) |
Inicializuje novou instanci PerformanceCounter třídy jen pro čtení a přidruží ji k zadanému systému nebo vlastnímu čítači výkonu a instanci kategorie v zadaném počítači. |
Pole
| DefaultFileMappingSize |
Zastaralé.
Zastaralé.
Zastaralé.
Určuje velikost globální paměti sdílené čítači výkonu v bajtech. Výchozí velikost je 524 288 bajtů. |
Vlastnosti
| CanRaiseEvents |
Získá hodnotu označující, zda komponenta může vyvolat událost. (Zděděno od Component) |
| CategoryName |
Získá nebo nastaví název kategorie čítače výkonu pro tento čítač výkonu. |
| Container |
Získá objekt IContainer , který obsahuje Component. (Zděděno od Component) |
| CounterHelp |
Získá popis pro tento čítač výkonu. |
| CounterName |
Získá nebo nastaví název čítače výkonu, který je přidružen k této PerformanceCounter instanci. |
| CounterType |
Získá typ čítače přidruženého čítače výkonu. |
| DesignMode |
Získá hodnotu, která označuje, zda je aktuálně v režimu návrhu Component . (Zděděno od Component) |
| Events |
Získá seznam obslužných rutin událostí, které jsou připojeny k tomuto Component. (Zděděno od Component) |
| InstanceLifetime |
Získá nebo nastaví životnost procesu. |
| InstanceName |
Získá nebo nastaví název instance pro tento čítač výkonu. |
| MachineName |
Získá nebo nastaví název počítače pro tento čítač výkonu. |
| RawValue |
Získá nebo nastaví nezpracovanou nebo nepřepočítanou hodnotu tohoto čítače. |
| ReadOnly |
Získá nebo nastaví hodnotu označující, zda je tato PerformanceCounter instance v režimu jen pro čtení. |
| Site |
Získá nebo nastaví ISite hodnotu Component. (Zděděno od Component) |
Metody
| BeginInit() |
Zahájí inicializaci PerformanceCounter instance používané ve formuláři nebo jinou komponentou. Inicializace probíhá za běhu. |
| Close() |
Zavře čítač výkonu a uvolní všechny prostředky přidělené touto instancí čítače výkonu. |
| CloseSharedResources() |
Uvolní sdílený stav knihovny čítačů výkonu přidělený čítači. |
| CreateObjRef(Type) |
Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy používaného ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject) |
| Decrement() |
Sníží přidružený čítač výkonu o jeden prostřednictvím efektivní atomické operace. |
| Dispose() |
Uvolní všechny prostředky používané nástrojem Component. (Zděděno od Component) |
| Dispose(Boolean) |
Uvolní nespravované prostředky používané Component nástrojem a volitelně uvolní spravované prostředky. (Zděděno od Component) |
| EndInit() |
Ukončí inicializaci PerformanceCounter instance, která se používá ve formuláři nebo v jiné komponentě. Inicializace probíhá za běhu. |
| Equals(Object) |
Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object) |
| GetHashCode() |
Slouží jako výchozí hashovací funkce. (Zděděno od Object) |
| GetLifetimeService() |
Zastaralé.
Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject) |
| GetService(Type) |
Vrátí objekt, který představuje službu poskytovanou objektem Component nebo jejím Containerobjektem . (Zděděno od Component) |
| GetType() |
Získá aktuální Type instanci. (Zděděno od Object) |
| Increment() |
Zvýší přidružený čítač výkonu o jeden prostřednictvím efektivní atomické operace. |
| IncrementBy(Int64) |
Zvýší nebo sníží hodnotu přidruženého čítače výkonu o zadanou hodnotu prostřednictvím efektivní atomické operace. |
| InitializeLifetimeService() |
Zastaralé.
Získá objekt služby životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject) |
| MemberwiseClone() |
Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object) |
| MemberwiseClone(Boolean) |
Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject) |
| NextSample() |
Získá vzorek čítače a vrátí nezpracovanou nebo nepřepočítanou hodnotu. |
| NextValue() |
Získá vzorek čítače a vrátí pro něj vypočítanou hodnotu. |
| RemoveInstance() |
Odstraní instanci kategorie určenou vlastností objektu PerformanceCounterInstanceName . |
| ToString() |
String Vrátí hodnotu obsahující název Component, pokud existuje. Tato metoda by neměla být přepsána. (Zděděno od Component) |
Událost
| Disposed |
Nastane, když je komponenta odstraněna voláním Dispose() metody. (Zděděno od Component) |
