Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

PerformanceCounter-Klasse

Stellt eine Komponente eines Windows NT-Leistungsindikators dar.

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

public sealed class PerformanceCounter : Component, ISupportInitialize
public final class PerformanceCounter extends Component implements ISupportInitialize
public final class PerformanceCounter extends Component implements ISupportInitialize

HinweisHinweis

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.

HinweisWichtig:

   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.

VorsichtVorsicht

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.

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


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("++++++++++++++++++++++");
	}
}

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

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

Dieser Typ ist sicher bei Multithreadoperationen.

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.

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0
Anzeigen: