PerformanceCounter Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Stellt eine Windows NT-Leistungsindikatorkomponente dar.
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- Vererbung
- Implementiert
Beispiele
Im folgenden Codebeispiel wird die Verwendung der PerformanceCounter -Klasse zum Erstellen und Verwenden eines Zählertyps AverageCount64 veranschaulicht. Im Beispiel werden Kategorien erstellt, Indikatoren eingerichtet, Daten aus den Leistungsindikatoren gesammelt und die CounterSampleCalculator -Klasse aufgerufen, um die Leistungsindikatordaten zu interpretieren. Die Zwischen- und Endergebnisse werden im Konsolenfenster angezeigt. Weitere Beispiele für andere Leistungsindikatortypen finden Sie in der PerformanceCounterType -Enumeration.
#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
Hinweise
Die PerformanceCounter -Komponente kann sowohl zum Lesen vorhandener vordefinierter oder benutzerdefinierter Leistungsindikatoren als auch zum Veröffentlichen (Schreiben) von Leistungsdaten in benutzerdefinierten Leistungsindikatoren verwendet werden.
Im Dialogfeld Indikatoren hinzufügen von Windows Leistungsmonitor sind zahlreiche vordefinierte Leistungsindikatoren aufgeführt. Weitere Informationen zu den .NET Framework Leistungsindikatoren finden Sie unter Leistungsindikatoren.
Dieser Typ implementiert die IDisposable-Schnittstelle. Nach Abschluss der Verwendung sollten Sie den Typ entweder direkt oder indirekt löschen. Zum direkten Löschen des Typs rufen Sie seine Dispose-Methode in einem try/catch-Block auf. Zum indirekten Löschen verwenden Sie ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt „Verwenden eines Objekts, das IDisposable implementiert“ des Themas „Die IDisposable-Schnittstelle“.
Wichtig
In den Versionen 1.0 und 1.1 von .NET Framework erfordert diese Klasse, dass sofortige Aufrufer vollständig vertrauenswürdig sind. Ab .NET Framework Version 2.0 sind für diese Klasse bestimmte Aktionen erforderlichPerformanceCounterPermission. Es wird dringend empfohlen, semi-vertrauenswürdigen PerformanceCounterPermission Code nicht zu gewähren. Die Möglichkeit, Leistungsindikatoren zu lesen und zu schreiben, ermöglicht code das Ausführen von Aktionen, z. B. das Aufzählen ausführender Prozesse und das Abrufen von Informationen darüber.
Darüber hinaus kann die Übergabe eines PerformanceCounter Objekts an weniger vertrauenswürdigen Code zu einem Sicherheitsproblem führen. Übergeben Sie Niemals Leistungsindikatorobjekte, z. B. ein PerformanceCounterCategory oder PerformanceCounter, an weniger vertrauenswürdigen Code.
Um aus einem Leistungsindikator zu lesen, erstellen Sie eine instance der PerformanceCounter -Klasse, legen Sie die CategoryNameEigenschaften , CounterNameund optional die InstanceName Eigenschaften oder festMachineName, und rufen Sie dann die NextValue -Methode auf, um einen Leistungsindikator zu lesen.
Um Leistungsindikatordaten zu veröffentlichen, erstellen Sie mithilfe der PerformanceCounterCategory.Create -Methode einen oder mehrere benutzerdefinierte Leistungsindikatoren, erstellen Sie eine instance der PerformanceCounter -Klasse, legen Sie die CategoryNameEigenschaften , CounterName und optional InstanceName oder festMachineName, und rufen Sie dann die IncrementByMethoden , Incrementoder Decrement auf, oder legen Sie die RawValue -Eigenschaft fest, um den Wert ihres benutzerdefinierten Leistungsindikators zu ändern.
Hinweis
Die IncrementMethoden , IncrementByund Decrement verwenden Interlocks, um den Zählerwert zu aktualisieren. Dies trägt dazu bei, den Zählerwert in Multithread- oder Multiprozessszenarien genau zu halten, führt aber auch zu Leistungseinbußen. Wenn Sie die Genauigkeit, die ineinandergreifende Vorgänge bieten, nicht benötigen, können Sie die Eigenschaft direkt aktualisieren, um die RawValue Leistung um das Fünffache zu verbessern. In Multithreadszenarien werden jedoch einige Aktualisierungen des Zählerwerts möglicherweise ignoriert, was zu ungenauen Daten führt.
Der Leistungsindikator ist der Mechanismus, mit dem Leistungsdaten gesammelt werden. Die Registrierung speichert die Namen aller Leistungsindikatoren, die jeweils mit einem bestimmten Bereich der Systemfunktionalität verknüpft sind. Beispiele hierfür sind die Auslastung eines Prozessors, die Speicherauslastung oder die Anzahl der Bytes, die über eine Netzwerkverbindung empfangen werden.
Jeder Zähler wird durch seinen Namen und seine Position eindeutig identifiziert. Auf die gleiche Weise, wie ein Dateipfad ein Laufwerk, ein Verzeichnis, ein oder mehrere Unterverzeichnisse und einen Dateinamen enthält, bestehen leistungsindikatorinformationen aus vier Elementen: dem Computer, der Kategorie, der Kategorie instance und dem Indikatornamen.
Die Zählerinformationen müssen die Kategorie oder das Leistungsobjekt enthalten, für die der Zähler Daten misst. Zu den Kategorien eines Computers gehören physische Komponenten wie Prozessoren, Datenträger und Arbeitsspeicher. Es gibt auch Systemkategorien, z. B. Prozesse und Threads. Jede Kategorie bezieht sich auf ein funktionales Element innerhalb des Computers und verfügt über eine Reihe von Standardindikatoren, die ihm zugewiesen sind. Diese Objekte werden in der Dropdownliste Leistungsobjekt des Dialogfelds Leistungsindikatoren hinzufügen im Windows 2000-Systemmonitor aufgeführt, und Sie müssen sie in den Indikatorpfad einschließen. Leistungsdaten werden nach der Kategorie gruppiert, auf die sie sich beziehen.
In bestimmten Fällen können mehrere Kopien derselben Kategorie vorhanden sein. Beispielsweise werden mehrere Prozesse und Threads gleichzeitig ausgeführt, und einige Computer enthalten mehr als einen Prozessor. Die Kategoriekopien werden als Kategorieinstanzen bezeichnet, und jeder instance ist eine Reihe von Standardindikatoren zugewiesen. Wenn eine Kategorie mehrere instance haben kann, muss eine instance Spezifikation in die Zählerinformationen aufgenommen werden.
Um Leistungsdaten für Leistungsindikatoren zu erhalten, die einen anfangs oder vorherigen Wert zum Ausführen der erforderlichen Berechnung erforderten, rufen Sie die NextValue -Methode zweimal auf, und verwenden Sie die zurückgegebenen Informationen nach Bedarf für Ihre Anwendung.
Hinweis
Leistungsindikatorkategorien, die mit dem .NET Framework 2.0 installiert werden, verwenden separaten freigegebenen Arbeitsspeicher, wobei jede Leistungsindikatorkategorie über einen eigenen Arbeitsspeicher verfügt. Sie können die Größe des separaten freigegebenen Arbeitsspeichers angeben, indem Sie im Registrierungsschlüssel HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<Kategoriename>\Leistung ein DWORD namens FileMappingSize erstellen. Der Wert FileMappingSize wird auf die Größe des freigegebenen Arbeitsspeichers der Kategorie festgelegt. Die Standardgröße ist 131072 dezimal. Wenn der FileMappingSize-Wert nicht vorhanden ist, wird der fileMappingSize Attributwert für das performanceCounters in der Machine.config-Datei angegebene Element verwendet, was zusätzlichen Mehraufwand für die Verarbeitung der Konfigurationsdatei verursacht. Sie können eine Leistungsverbesserung für den Anwendungsstart erzielen, indem Sie die Dateizuordnungsgröße in der Registrierung festlegen. Weitere Informationen zur Größe der Dateizuordnung finden Sie unter <performanceCounters>.
Konstruktoren
| PerformanceCounter() |
Initialisiert eine neue, schreibgeschützte Instanz der PerformanceCounter-Klasse, ohne diese Instanz einem System- oder benutzerdefinierten Leistungsindikator zuzuordnen. |
| PerformanceCounter(String, String) |
Initialisiert eine neue, schreibgeschützte Instanz der PerformanceCounter-Klasse und ordnet sie dem angegebenen System- oder benutzerdefinierten Leistungsindikator auf dem lokalen Computer zu. Für diesen Konstruktor muss die Kategorie eine einzelne Instanz besitzen. |
| PerformanceCounter(String, String, Boolean) |
Initialisiert eine neue Instanz der PerformanceCounter-Klasse im schreibgeschützten oder Lese-/Schreibmodus und ordnet sie dem angegebenen System- oder benutzerdefinierten Leistungsindikator auf dem lokalen Computer zu. Für diesen Konstruktor muss die Kategorie eine einzelne Instanz enthalten. |
| PerformanceCounter(String, String, String) |
Initialisiert eine neue, schreibgeschützte Instanz der PerformanceCounter-Klasse und ordnet sie dem angegebenen System- oder benutzerdefinierten Leistungsindikator sowie der angegebenen Kategorieinstanz auf dem lokalen Computer zu. |
| PerformanceCounter(String, String, String, Boolean) |
Initialisiert eine neue Instanz der PerformanceCounter-Klasse im schreibgeschützten oder Lese-/Schreibmodus und ordnet sie dem angegebenen System- oder benutzerdefinierten Leistungsindikator und der angegebenen Kategorieinstanz auf dem lokalen Computer zu. |
| PerformanceCounter(String, String, String, String) |
Initialisiert eine neue, schreibgeschützte Instanz der PerformanceCounter-Klasse und ordnet sie dem angegebenen System- oder benutzerdefinierten Leistungsindikator sowie der angegebenen Kategorieinstanz auf dem angegebenen Computer zu. |
Felder
| DefaultFileMappingSize |
Veraltet.
Veraltet.
Veraltet.
Gibt die Größe des globalen Speichers (in Bytes) an, der von den Leistungsindikatoren gemeinsam genutzt wird. Die Standardgröße ist 524.288 Bytes. |
Eigenschaften
| CanRaiseEvents |
Ruft einen Wert ab, der angibt, ob die Komponente ein Ereignis auslösen kann. (Geerbt von Component) |
| CategoryName |
Ruft den Namen der Leistungsindikatorkategorie für diesen Leistungsindikator ab oder legt diesen fest. |
| Container |
Ruft die IContainer ab, die in der Component enthalten ist. (Geerbt von Component) |
| CounterHelp |
Ruft die Beschreibung für diesen Leistungsindikator ab. |
| CounterName |
Ruft den Namen des Leistungsindikators ab, der dieser PerformanceCounter-Instanz zugeordnet ist, oder legt diesen fest. |
| CounterType |
Ruft den Zählertyp des zugeordneten Leistungsindikators ab. |
| DesignMode |
Ruft einen Wert ab, der angibt, ob sich Component gegenwärtig im Entwurfsmodus befindet. (Geerbt von Component) |
| Events |
Ruft die Liste der Ereignishandler ab, die dieser Component angefügt sind. (Geerbt von Component) |
| InstanceLifetime |
Ruft die Lebenszeit eines Prozesses ab oder legt diese fest. |
| InstanceName |
Ruft einen Instanznamen für diesen Leistungsindikator ab oder legt diesen fest. |
| MachineName |
Ruft den Computernamen für diesen Leistungsindikator ab oder legt diesen fest. |
| RawValue |
Ruft den unformatierten bzw. nicht berechneten Wert dieses Zählers ab oder legt diesen fest. |
| ReadOnly |
Ruft einen Wert ab, der angibt, ob sich diese PerformanceCounter-Instanz im schreibgeschützten Modus befindet, oder legt diesen fest. |
| Site |
Ruft den ISite von Component ab oder legt ihn fest. (Geerbt von Component) |
Methoden
| BeginInit() |
Beginnt die Initialisierung einer PerformanceCounter-Instanz für die Verwendung in einem Formular oder durch eine andere Komponente. Die Initialisierung erfolgt zur Laufzeit. |
| Close() |
Beendet den Leistungsindikator und gibt sämtliche von dieser Leistungsindikatorinstanz reservierten Ressourcen frei. |
| CloseSharedResources() |
Setzt die von den Zählern angeforderte gemeinsame Verwendung der Leistungsindikatorenbibliothek zurück. |
| CreateObjRef(Type) |
Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject) |
| Decrement() |
Dekrementiert durch eine effiziente atomare Operation den zugeordneten Leistungsindikator um eins. |
| Dispose() |
Gibt alle vom Component verwendeten Ressourcen frei. (Geerbt von Component) |
| Dispose(Boolean) |
Gibt die von Component verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. (Geerbt von Component) |
| EndInit() |
Beendet die Initialisierung einer PerformanceCounter-Instanz, die in einem Formular oder von einer anderen Komponente verwendet wird. Die Initialisierung erfolgt zur Laufzeit. |
| Equals(Object) |
Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object) |
| GetHashCode() |
Fungiert als Standardhashfunktion. (Geerbt von Object) |
| GetLifetimeService() |
Veraltet.
Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject) |
| GetService(Type) |
Gibt ein Objekt zurück, das einen von der Component oder von deren Container bereitgestellten Dienst darstellt. (Geerbt von Component) |
| GetType() |
Ruft den Type der aktuellen Instanz ab. (Geerbt von Object) |
| Increment() |
Inkrementiert durch eine effiziente atomare Operation den zugeordneten Leistungsindikator um eins. |
| IncrementBy(Int64) |
Inkrementiert oder dekrementiert durch eine effiziente atomare Operation den Wert des zugeordneten Leistungsindikators um einen angegebenen Betrag. |
| InitializeLifetimeService() |
Veraltet.
Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject) |
| MemberwiseClone() |
Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object) |
| MemberwiseClone(Boolean) |
Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject) |
| NextSample() |
Ruft eine Zählermessung ab und gibt dafür den unformatierten bzw. nicht berechneten Wert zurück. |
| NextValue() |
Ruft eine Zählermessung ab und gibt den dafür berechneten Wert zurück. |
| RemoveInstance() |
Löscht die von der PerformanceCounter-Eigenschaft des InstanceName-Objekts angegebene Kategorieinstanz. |
| ToString() |
Gibt einen String zurück, der den Namen der Component enthält (sofern vorhanden). Diese Methode darf nicht überschrieben werden. (Geerbt von Component) |
Ereignisse
| Disposed |
Tritt auf, wenn die Komponente von einem Aufruf der Dispose()-Methode verworfen wird. (Geerbt von Component) |
