PerformanceCounter-Klasse

Stellt eine Komponente eines Windows NT-Leistungsindikators dar.

System.Object
  System.MarshalByRefObject
    System.ComponentModel.Component
      System.Diagnostics.PerformanceCounter

Namespace:  System.Diagnostics
Assembly:  System (in System.dll)

[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	SharedState = true)]
public sealed class PerformanceCounter : Component, 
	ISupportInitialize

Der PerformanceCounter-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche MethodePerformanceCounter()Initialisiert eine neue, schreibgeschützte Instanz der PerformanceCounter-Klasse, ohne diese Instanz einem System- oder benutzerdefinierten Leistungsindikator zuzuordnen.
Öffentliche MethodePerformanceCounter(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.
Öffentliche MethodePerformanceCounter(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.
Öffentliche MethodePerformanceCounter(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.
Öffentliche MethodePerformanceCounter(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.
Öffentliche MethodePerformanceCounter(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.
Zum Seitenanfang

  NameBeschreibung
Öffentliche EigenschaftCategoryNameRuft den Namen der Leistungsindikatorkategorie für diesen Leistungsindikator ab oder legt diesen fest.
Öffentliche EigenschaftContainerRuft den IContainer ab, der die Component enthält. (Von Component geerbt.)
Öffentliche EigenschaftCounterHelpRuft die Beschreibung für diesen Leistungsindikator ab.
Öffentliche EigenschaftCounterNameRuft den Namen des Leistungsindikators ab, der dieser PerformanceCounter-Instanz zugeordnet ist, oder legt diesen fest.
Öffentliche EigenschaftCounterTypeRuft den Zählertyp des zugeordneten Leistungsindikators ab.
Öffentliche EigenschaftInstanceLifetimeRuft die Lebenszeit eines Prozesses ab oder legt diese fest.
Öffentliche EigenschaftInstanceNameRuft einen Instanznamen für diesen Leistungsindikator ab oder legt diesen fest.
Öffentliche EigenschaftMachineNameRuft den Computernamen für diesen Leistungsindikator ab oder legt diesen fest.
Öffentliche EigenschaftRawValueRuft den unformatierten bzw. nicht berechneten Wert dieses Zählers ab oder legt diesen fest.
Öffentliche EigenschaftReadOnlyRuft einen Wert ab, der angibt, ob sich diese PerformanceCounter-Instanz im schreibgeschützten Modus befindet, oder legt diesen fest.
Öffentliche EigenschaftSiteRuft die ISite der Component ab oder legt diese fest. (Von Component geerbt.)
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeBeginInitBeginnt die Initialisierung einer PerformanceCounter-Instanz für die Verwendung in einem Formular oder durch eine andere Komponente. Die Initialisierung erfolgt zur Laufzeit.
Öffentliche MethodeCloseBeendet den Leistungsindikator und gibt sämtliche von dieser Leistungsindikatorinstanz reservierten Ressourcen frei.
Öffentliche MethodeStatischer MemberCloseSharedResourcesSetzt die von den Zählern angeforderte gemeinsame Verwendung der Leistungsindikatorenbibliothek zurück.
Öffentliche MethodeCreateObjRefErstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeDecrementDekrementiert durch eine effiziente atomare Operation den zugeordneten Leistungsindikator um eins.
Öffentliche MethodeDispose() Gibt alle von Component verwendeten Ressourcen frei. (Von Component geerbt.)
Öffentliche MethodeEndInitBeendet die Initialisierung einer PerformanceCounter-Instanz, die in einem Formular oder von einer anderen Komponente verwendet wird. Die Initialisierung erfolgt zur Laufzeit.
Öffentliche MethodeEquals(Object)Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. (Von Object geerbt.)
Öffentliche MethodeGetHashCodeFungiert als die Standardhashfunktion. (Von Object geerbt.)
Öffentliche MethodeGetLifetimeServiceRuft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeIncrementInkrementiert durch eine effiziente atomare Operation den zugeordneten Leistungsindikator um eins.
Öffentliche MethodeIncrementByInkrementiert oder dekrementiert durch eine effiziente atomare Operation den Wert des zugeordneten Leistungsindikators um einen angegebenen Betrag.
Öffentliche MethodeInitializeLifetimeServiceRuft ein Lebensdauerdienstobjekt ab, mit dem die Lebensdauerrichtlinien für diese Instanz gesteuert werden können. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeNextSampleRuft eine Zählermessung ab und gibt dafür den unformatierten bzw. nicht berechneten Wert zurück.
Öffentliche MethodeNextValueRuft eine Zählermessung ab und gibt den dafür berechneten Wert zurück.
Öffentliche MethodeRemoveInstanceLöscht die von der InstanceName-Eigenschaft des PerformanceCounter-Objekts angegebene Kategorieinstanz.
Öffentliche MethodeToStringGibt einen String zurück, der den Namen dieser Component enthält, sofern vorhanden. Diese Methode sollte nicht überschrieben werden. (Von Component geerbt.)
Zum Seitenanfang

  NameBeschreibung
Öffentliches EreignisDisposed Wird ausgelöst, wenn die Komponente durch einen Aufruf der Dispose-Methode freigegeben wird. (Von Component geerbt.)
Zum Seitenanfang

  NameBeschreibung
Öffentliches FeldStatischer MemberDefaultFileMappingSize 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.
Zum Seitenanfang

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.

Wichtiger HinweisWichtig

   In Version1.0 und 1.1 von .NET Framework müssen unmittelbare Aufrufer dieser Klasse voll vertrauenswürdig sein. Mit .NET Framework, Version 2.0, beginnend, erfordert diese Klasse PerformanceCounterPermission für bestimmte Aktionen. 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.

WarnhinweisVorsicht

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.

Die vordefinierten Indikatoren sind zu zahlreich um sie hier zu berücksichtigen. Sie können eine Liste der verfügbaren bereits vorhandenen Indikatoren im Windows-Systemmonitor abrufen, siehe Fügen Sie Indikatordialogfeld hinzu. Informationen zu den .NET Framework-Leistungsindikatoren finden Sie unter Leistungsindikatoren in .NET Framework.

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.

HinweisHinweis

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 physische 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.

HinweisHinweis

Leistungsindikatorkategorien, die mit .NET Framework 2.0 installiert werden, verwenden getrennte gemeinsam genutzte Speicherbereiche, bei denen jeder Leistungsindikator über einen eigenen Speicherbereich verfügt. Sie können die Größe des separaten gemeinsamen Speichers angeben, indem Sie im Registrierungsschlüssel HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<Kategoriename>\Performance das DWORD FileMappingSize erstellen. Der FileMappingSize-Wert wird auf die Größe des gemeinsamen Speichers der Kategorie festgelegt. Die Standardgröße ist 131072 (dezimal). Wenn der FileMappingSize-Wert nicht vorhanden ist, wird der fileMappingSize-Attributwert für das in der Datei Machine.config angegebene performanceCounters-Element verwendet, was zu zusätzlichem Aufwand für die Verarbeitung der Konfigurationsdatei führt. Sie können eine Leistungsverbesserung für den Anwendungsstart erzielen, indem Sie die Dateizuordnungsgröße in der Registrierung festlegen. Weitere Informationen zur Dateizuordnungsgröße finden Sie unter <performanceCounters>-Element.

HinweisHinweis

Das HostProtectionAttribute -Attribut, das auf diesen Typ oder Member angewendet wird, besitzt den folgenden Resources Eigenschaftswert: Synchronization | SharedState. Das HostProtectionAttribute hat keine Auswirkungen auf Desktopanwendungen (die normalerweise durch Doppelklicken auf ein Symbol, Eingeben eines Befehls oder einer URL in einem Browser gestartet werden). Weitere Informationen finden Sie unter HostProtectionAttribute -Klasse oder SQL Server-Programmierung und Hostschutzattribute.

Hinweis zur -Plattform: Leistungsindikatoren werden unter Windows 98 oder Windows Millennium Edition (Me) nicht unterstützt.

Im folgenden Codebeispiel wird die Verwendung der PerformanceCounter-Klasse zum Erstellen und Verwenden eines AverageCount64-Zählertyps veranschaulicht. In dem Beispiel werden Kategorien erstellt, Zähler eingerichtet, Daten der Zähler erfasst, und die CounterSampleCalculator-Klasse wird 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;
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("++++++++++++++++++++++");
	}
}


.NET Framework

Unterstützt in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

Es werden nicht alle Versionen sämtlicher Plattformen von .NET Framework unterstützt.. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Alle öffentlichen static (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.
Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Vielen Dank für Ihr Feedback.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft