PerformanceCounter-Klasse
Stellt eine Komponente eines Windows NT-Leistungsindikators dar.
Namespace: System.Diagnostics
Assembly: System (in system.dll)
Syntax
'Declaration
Public NotInheritable Class PerformanceCounter
Inherits Component
Implements ISupportInitialize
'Usage
Dim instance As PerformanceCounter
public sealed class PerformanceCounter : Component, ISupportInitialize
public ref class PerformanceCounter sealed : public Component, ISupportInitialize
public final class PerformanceCounter extends Component implements ISupportInitialize
public final class PerformanceCounter extends Component implements ISupportInitialize
Hinweise
Hinweis
Das auf diese Klasse angewendete HostProtectionAttribute-Attribut besitzt den Resources-Eigenschaftenwert Synchronization | SharedState. Das HostProtectionAttribute hat keine Auswirkungen auf Desktopanwendungen (die normalerweise durch Doppelklicken auf ein Symbol, Eingeben eines Befehls oder eines URL in einem Browser gestartet werden). Weitere Informationen finden Sie unter der HostProtectionAttribute-Klasse oder unter SQL Server-Programmierung und Hostschutzattribute.
Mit der PerformanceCounter-Komponente können vorhandene vordefinierte oder benutzerdefinierte Zähler gelesen sowie Leistungsdaten in benutzerdefinierte Zähler geschrieben bzw. darin veröffentlicht werden.
Wichtig
In Version1.0 und 1.1 von .NET Framework müssen unmittelbare Aufrufer dieser Klasse voll vertrauenswürdig sein. In Version 2.0 erfordert diese Klasse für bestimme Aktionen PerformanceCounterPermission. Es wird dringend empfohlen, PerformanceCounterPermission nicht für halb vertrauenswürdigen Code zu erteilen. Durch die Fähigkeit, Leistungsindikatoren zu lesen und zu schreiben, kann Code z. B. Ausführungsprozesse auflisten und Informationen über diese abrufen.
Warnung
Das Übergeben eines PerformanceCounter-Objekts an weniger vertrauenswürdigen Code kann zu einem Sicherheitsproblem führen. Übergeben Sie Leistungsindikatorobjekte, z. B. PerformanceCounterCategory oder PerformanceCounter, nicht an weniger vertrauenswürdigen Code.
Zum Lesen aus einem Leistungsindikator erstellen Sie eine Instanz der PerformanceCounter-Klasse, legen CategoryName-Eigenschaft, die CounterName-Eigenschaft und optional die InstanceName-Eigenschaft oder die MachineName-Eigenschaft fest und rufen dann die NextValue-Methode auf.
Zum Veröffentlichen von Leistungsindikatordaten erstellen Sie mithilfe der PerformanceCounterCategory.Create-Methode mindestens einen benutzerdefinierten Zähler. Anschließend erstellen Sie eine Instanz der PerformanceCounter-Klasse, legen die CategoryName-Eigenschaft, die CounterName-Eigenschaft und optional die InstanceName-Eigenschaft oder die MachineName-Eigenschaft fest und rufen dann die IncrementBy-Methode, die Increment-Methode oder die Decrement-Methode auf oder legen die RawValue-Eigenschaft fest, um den Wert des benutzerdefinierten Zählers zu ändern.
Hinweis
Die Methoden Increment, IncrementBy und Decrement verwendet Interlocks zum Aktualisieren des Zählerwerts. Dies erhöht die Genauigkeit des Zählerwerts in Szenarien mit mehreren Threads oder Prozessen, wirkt sich jedoch negativ auf die Leistung aus. Wenn Sie die Genauigkeit von Interlockoperationen nicht benötigen, können Sie die RawValue-Eigenschaft direkt aktualisieren, woraus sich eine bis zu fünffache Leistungsverbesserung ergibt. Szenarien mit mehreren Threads werden möglicherweise einige Aktualisierungen des Zählerwerts ignoriert, was zu ungenauen Daten führt.
Der Zähler ist der Mechanismus, mit dem Leistungsdaten zusammengestellt werden. In der Registrierung sind die Namen sämtlicher Zähler gespeichert, von denen jeder mit einem bestimmten Bereich von Systemfunktionen verknüpft ist. Dazu zählen die Auslastungszeit eines Prozessors, die Speicherauslastung oder die über eine Netzwerkverbindung empfangene Anzahl von Bytes.
Jeder Zähler ist durch seinen Namen und seine Position eindeutig gekennzeichnet. Ähnlich wie Dateipfade, die ein Laufwerk, ein Verzeichnis, ein oder mehrere Unterverzeichnisse und einen Dateinamen enthalten, bestehen Zählerinformationen aus vier Elementen: dem Computer, der Kategorie, der Kategorieinstanz und dem Zählernamen.
Die Zählerinformationen müssen die Kategorie bzw. das Leistungsobjekt enthalten, dessen Daten durch den Zähler gemessen werden. Die Kategorien eines Computers umfassen physikalische Komponenten, z. B. Prozessoren, Datenträger und Speicher. Daneben gibt es Systemkategorien, z. B. Prozesse und Threads. Jede Kategorie bezieht sich auf ein Funktionselement des Computers, und jeder Kategorie ist eine Reihe von Standardzählern zugewiesen. Diese Objekte sind im Systemmonitor von Windows 2000 im Dialogfeld Leistungsindikatoren hinzufügen in der Dropdownliste Datenobjekt aufgeführt und müssen im Zählerpfad angegeben werden. Leistungsdaten werden nach den Kategorien gruppiert, denen sie zugeordnet sind.
In bestimmten Fällen können mehrere Kopien einer Kategorie vorhanden sein. Es können z B. mehrere Prozesse und Threads gleichzeitig ausgeführt werden oder mehrere Prozessoren in einem Computer enthalten sein. Die Kopien der Kategorie werden als Kategorieinstanzen bezeichnet, wobei jeder Instanz eine Reihe von Standardzählern zugewiesen ist. Wenn eine Kategorie mehrere Instanzen beinhalten kann, müssen die Zählerinformationen eine Instanzspezifikation enthalten.
Zum Abrufen von Leistungsdaten für Zähler, die für die erforderliche Berechnung einen Anfangs- oder vorherigen Wert benötigen, rufen Sie die NextValue-Methode zweimal auf, und verwenden die zurückgegebenen Informationen entsprechend den Anforderungen der Anwendung.
Hinweis zu Windows 98, Windows Millennium Edition: Leistungsindikatoren werden unter Windows 98 oder Windows Millennium Edition (Me) nicht unterstützt.
Beispiel
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
_
Public Class App
Private Shared PC As PerformanceCounter
Private Shared BPC As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
SetupCategory()
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End Sub 'Main
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") Then
Dim CCDC As New CounterCreationDataCollection()
' Add the counter.
Dim averageCount64 As New CounterCreationData()
averageCount64.CounterType = PerformanceCounterType.AverageCount64
averageCount64.CounterName = "AverageCounter64Sample"
CCDC.Add(averageCount64)
' Add the base counter.
Dim averageCount64Base As New 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
End If
End Function 'SetupCategory
Private Shared Sub CreateCounters()
' Create the counters.
PC = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64Sample", False)
BPC = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64SampleBase", False)
PC.RawValue = 0
BPC.RawValue = 0
End Sub 'CreateCounters
Private Shared Sub CollectSamples(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 + " = " + value))
PC.IncrementBy(value)
BPC.Increment()
If j Mod 10 = 9 Then
OutputSample(PC.NextSample())
samplesList.Add(PC.NextSample())
Else
Console.WriteLine()
End If
System.Threading.Thread.Sleep(50)
Next j
End Sub 'CollectSamples
Private Shared Sub CalculateResults(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))))
' Calculate the counter value manually.
Console.WriteLine(("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample))))
Next i
End Sub 'CalculateResults
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
' 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(s0 As CounterSample, 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(s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
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("++++++++++++++++++++++")
End Sub 'OutputSample
End Class 'App
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
public class App {
private static PerformanceCounter PC;
private static PerformanceCounter BPC;
public static void Main()
{
ArrayList samplesList = new ArrayList();
SetupCategory();
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if ( !PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") )
{
CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageCount64 = new CounterCreationData();
averageCount64.CounterType = PerformanceCounterType.AverageCount64;
averageCount64.CounterName = "AverageCounter64Sample";
CCDC.Add(averageCount64);
// Add the base counter.
CounterCreationData averageCount64Base = new 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);
}
}
private static void CreateCounters()
{
// Create the counters.
PC = new PerformanceCounter("AverageCounter64SampleCategory",
"AverageCounter64Sample",
false);
BPC = new PerformanceCounter("AverageCounter64SampleCategory",
"AverageCounter64SampleBase",
false);
PC.RawValue=0;
BPC.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);
PC.IncrementBy(value);
BPC.Increment();
if ((j % 10) == 9)
{
OutputSample(PC.NextSample());
samplesList.Add( PC.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("++++++++++++++++++++++");
}
}
#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 );
}
import System.*;
import System.Collections.*;
import System.Collections.Specialized.*;
import System.Diagnostics.*;
public class App
{
private static PerformanceCounter pc;
private static PerformanceCounter bpc;
public static void main(String[] args)
{
ArrayList samplesList = new ArrayList();
SetupCategory();
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
} //main
private static boolean SetupCategory()
{
if (!(PerformanceCounterCategory.Exists(
"AverageCounter64SampleCategory"))) {
CounterCreationDataCollection ccdc =
new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageCount64 = new CounterCreationData();
averageCount64.
set_CounterType(PerformanceCounterType.AverageCount64);
averageCount64.set_CounterName("AverageCounter64Sample");
ccdc.Add(averageCount64);
// Add the base counter.
CounterCreationData averageCount64Base = new CounterCreationData();
averageCount64Base.set_CounterType(PerformanceCounterType.
AverageBase);
averageCount64Base.set_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;
}
} //SetupCategory
private static void CreateCounters()
{
// Create the counters.
pc = new PerformanceCounter("AverageCounter64SampleCategory",
"AverageCounter64Sample", false);
bpc = new PerformanceCounter("AverageCounter64SampleCategory",
"AverageCounter64SampleBase", false);
pc.set_RawValue(0);
bpc.set_RawValue(0);
} //CreateCounters
private static void CollectSamples(ArrayList samplesList)
{
Random r = new Random(DateTime.get_Now().get_Millisecond());
// Loop for the samples.
for (int j = 0; j < 100; j++) {
int value = r.Next(1, 10);
Console.Write(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);
}
} //CollectSamples
private static void CalculateResults(ArrayList samplesList)
{
for (int i = 0; i < samplesList.get_Count() - 1; i++) {
// Output the sample.
OutputSample((CounterSample)samplesList.get_Item(i));
OutputSample((CounterSample)samplesList.get_Item(i + 1));
// Use.NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = "
+ CounterSampleCalculator.ComputeCounterValue((CounterSample)
samplesList.get_Item(i),
(CounterSample)samplesList.get_Item(i + 1)));
// Calculate the counter value manually.
Console.WriteLine("My computed counter value = "
+ MyComputeCounterValue((CounterSample)samplesList.get_Item(i),
(CounterSample)samplesList.get_Item(i + 1)));
}
} //CalculateResults
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
//++++++++
// 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 float MyComputeCounterValue(CounterSample s0,
CounterSample s1)
{
float numerator = (float)s1.get_RawValue() - (float)s0.get_RawValue();
float denomenator = (float)s1.get_BaseValue() - (float)s0.
get_BaseValue();
float counterValue = numerator / denomenator;
return counterValue;
} //MyComputeCounterValue
// 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.get_BaseValue());
Console.WriteLine(" CounterFrequency = " + s.get_CounterFrequency());
Console.WriteLine(" CounterTimeStamp = " + s.get_CounterTimeStamp());
Console.WriteLine(" CounterType = " + s.get_CounterType());
Console.WriteLine(" RawValue = " + s.get_RawValue());
Console.WriteLine(" SystemFrequency = " + s.get_SystemFrequency());
Console.WriteLine(" TimeStamp = " + s.get_TimeStamp());
Console.WriteLine(" TimeStamp100nSec = " + s.get_TimeStamp100nSec());
Console.WriteLine("++++++++++++++++++++++");
} //OutputSample
} //App
Vererbungshierarchie
System.Object
System.MarshalByRefObject
System.ComponentModel.Component
System.Diagnostics.PerformanceCounter
Threadsicherheit
Dieser Typ ist sicher bei Multithreadoperationen.
Plattformen
Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
Siehe auch
Referenz
PerformanceCounter-Member
System.Diagnostics-Namespace
PerformanceCounterType
CounterCreationData-Klasse
CounterCreationDataCollection-Klasse
CounterSample-Struktur
CounterSampleCalculator-Klasse