Exporter (0) Imprimer
Développer tout
Développer Réduire
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

PerformanceCounterType, énumération

Spécifie la formule utilisée pour calculer la méthode NextValue pour une instance de PerformanceCounter.

Espace de noms :  System.Diagnostics
Assembly :  System (dans System.dll)

public enum PerformanceCounterType

Nom de membreDescription
AverageBaseCompteur de base utilisé lors du calcul des moyennes de temps ou de nombres, tel que AverageTimer32 et AverageCount64. Stocke le dénominateur de calcul d'un compteur en vue d'obtenir le « temps par opération » ou le « nombre par opération ».
AverageCount64Compteur de moyenne qui affiche le nombre d'éléments traités, en moyenne, au cours d'une opération. Les compteurs de ce type affichent un rapport entre les éléments traités et le nombre d'opérations exécutées. Le rapport est calculé en comparant le nombre d'éléments traités au cours du dernier intervalle et le nombre d'opérations exécutées au cours du dernier intervalle.

Formule: (N 1 - N 0)/(B 1 - B 0), où N 1 et N 0 sont des valeurs du compteur de performance, et où B 1 et B 0 sont leurs valeurs AverageBase correspondantes. Par conséquent, le numérateur représente le nombre d'éléments traités au cours de l'intervalle échantillon et le dénominateur représente le nombre d'opérations exécutées au cours de l'intervalle échantillon.

Les compteurs de ce type comprennent Disque physique\ Moy. disque, octets/transfert.

AverageTimer32Compteur de moyenne qui mesure le temps qui lui est nécessaire, en moyenne, pour exécuter un processus ou une opération. Les compteurs de ce type affichent un rapport entre le temps total écoulé de l'intervalle échantillon et le nombre de processus ou d'opérations exécutés au cours de ce temps. Ce type de compteur mesure le temps en graduations de l'horloge système.

Formule: (N 1 -N 0)/F)/(B 1 -B 0), où N 1 et N 0 sont des valeurs du compteur de performance, et où B 1 et B 0 sont leurs valeurs AverageBase correspondantes. La valeur de F est factorisée dans l'équation de sorte que le résultat puisse être affiché en secondes. Par conséquent, le numérateur représente le nombre de graduations comptées au cours du dernier intervalle échantillon, F représente la fréquence des graduations et le dénominateur représente le nombre d'opérations exécutées au cours du dernier intervalle échantillon.

Les compteurs de ce type comprennent Disque physique\ Moy. disque s/transfert.

CounterDelta32Compteur de différence qui affiche la modification de l'attribut mesuré entre les deux derniers intervalles échantillons.

Formule : N 1 -N 0, où N 1 et N 0 sont des valeurs du compteur de performance.

CounterDelta64Compteur de différence qui affiche la modification de l'attribut mesuré entre les deux derniers intervalles échantillons. Il est identique au type de compteur CounterDelta32, sauf qu'il utilise des champs plus étendus afin de contenir des valeurs plus élevées.

Formule : N 1 -N 0, où N 1 et N 0 sont des valeurs du compteur de performance.

CounterMultiBaseCompteur de base qui indique le nombre d'éléments échantillonnés. Il est utilisé comme dénominateur dans les calculs afin d'obtenir une moyenne parmi les éléments échantillonnés lors de la mesure de durée de plusieurs éléments similaires. Utilisé avec CounterMultiTimer, CounterMultiTimerInverse, CounterMultiTimer100Ns et CounterMultiTimer100NsInverse.
CounterMultiTimerCompteur de pourcentage qui affiche la durée d'activité d'un ou plusieurs composants sous forme de pourcentage du temps total de l'intervalle échantillon. Compte tenu que le numérateur enregistre la durée d'activité des composants fonctionnant simultanément, le pourcentage qui en résulte peut dépasser 100 pour cent.

Ce compteur est une multiminuterie. Les multiminuteries collectent des données provenant de plusieurs instances d'un composant, tel qu'un processeur ou un disque. Ce type de compteur diffère de CounterMultiTimer100Ns en ce sens qu'il mesure le temps en unités de graduations de la minuterie des performances système, plutôt qu'en unités de 100 nanosecondes.

Formule: ((N 1 - N 0) / (D 1 - D 0)) x 100 / B où N 1 et N 0 sont des valeurs du compteur de performance, D 1 et D 0 sont leurs valeurs temporelles correspondantes en graduations de la minuterie des performances système, et la variable B indique le nombre de base des composants surveillés (à l'aide d'un compteur de base du type CounterMultiBase). Par conséquent, le numérateur représente les parties de l'intervalle échantillon au cours duquel les composants surveillés étaient actifs, et le dénominateur représente le temps total écoulé de l'intervalle échantillon.

CounterMultiTimer100NsCompteur de pourcentage qui affiche la durée d'activité d'un ou plusieurs composants sous forme de pourcentage du temps total de l'intervalle échantillon. Il mesure le temps en unités de 100 nanosecondes (ns).

Ce type de compteur est une multiminuterie. Les multiminuteries sont conçues pour surveiller plusieurs instances d'un composant, tel qu'un processeur ou un disque.

Formule: ((N 1 - N 0) / (D 1 - D 0)) x 100 / B où N 1 et N 0 sont des valeurs du compteur de performance, D 1 et D 0 sont leurs valeurs temporelles correspondantes en unités de 100 nanosecondes, et la variable B indique le nombre de base des composants surveillés (à l'aide d'un compteur de base du type CounterMultiBase). Par conséquent, le numérateur représente les parties de l'intervalle échantillon au cours duquel les composants surveillés étaient actifs, et le dénominateur représente le temps total écoulé de l'intervalle échantillon.

CounterMultiTimer100NsInverseCompteur de pourcentage qui affiche la durée d'activité d'un ou plusieurs composants sous forme de pourcentage du temps total de l'intervalle échantillon. Les compteurs de ce type mesurent le temps en unités de 100 nanosecondes (ns). Ils dérivent le temps d'activité en mesurant le temps pendant lequel les composants étaient inactifs et en soustrayant le résultat de la multiplication de 100 pour cent par le nombre d'objets surveillés.

Ce type de compteur est une multiminuterie inverse. Les multiminuteries sont conçues pour surveiller plusieurs instances d'un composant, tel qu'un processeur ou un disque. Les compteurs inverses mesurent le temps pendant lequel un composant n'est pas actif et dérivent son temps d'activité à partir de la mesure de temps d'inactivité.

Formule : (B- ((N 1 - N 0) / (D 1 - D 0))) x 100, où le dénominateur représente le temps total écoulé de l'intervalle échantillon, le numérateur représente le temps au cours de l'intervalle où les composants surveillés étaient inactifs, et B représente le nombre de composants surveillés, à l'aide d'un compteur de base du type CounterMultiBase.

CounterMultiTimerInverseCompteur de pourcentage qui affiche la durée d'activité d'un ou plusieurs composants sous forme de pourcentage du temps total de l'intervalle échantillon. Il dérive le temps d'activité en mesurant le temps pendant lequel les composants n'étaient pas actifs et en soustrayant le résultat de la multiplication de 100 pour cent par le nombre d'objets surveillés.

Ce type de compteur est une multiminuterie inverse. Les multiminuteries surveillent plusieurs instances d'un composant, tel qu'un processeur ou un disque. Les compteurs inverses mesurent le temps pendant lequel un composant est inactif et dérivent son temps d'activité à partir de cette mesure.

Ce compteur diffère de CounterMultiTimer100NsInverse en ce sens qu'il mesure le temps en unités de graduations de la minuterie des performances système, plutôt qu'en unités de 100 nanosecondes.

Formule : (B- ((N 1 - N 0) / (D 1 - D 0))) x 100, où le dénominateur représente le temps total écoulé de l'intervalle échantillon, le numérateur représente le temps au cours de l'intervalle où les composants surveillés étaient inactifs, et B représente le nombre de composants surveillés, à l'aide d'un compteur de base du type CounterMultiBase.

CounterTimerCompteur de pourcentage qui affiche la durée moyenne d'activité d'un composant sous forme de pourcentage de la durée échantillon totale.

Formule: (N 1 - N 0) / (D 1 - D0), où N 1 et N 0 sont des valeurs du compteur de performance, et où D 1 et D 0 sont leurs valeurs temporelles correspondantes. Par conséquent, le numérateur représente les parties de l'intervalle échantillon au cours duquel les composants surveillés étaient actifs, et le dénominateur représente le temps total écoulé de l'intervalle échantillon.

CounterTimerInverseCompteur de pourcentage qui affiche le pourcentage moyen de temps d'activité observé au cours de l'intervalle échantillon. La valeur de ces compteurs est calculée en surveillant le pourcentage de temps au cours duquel le service était inactif, puis en soustrayant cette valeur de 100 pour cent.

Il s'agit d'un type de compteur inverse. Les compteurs inverses mesurent le temps pendant lequel un composant est inactif et dérivent le temps d'activité à partir de cette mesure. Ce type de compteur est identique à CounterTimer100NsInv, sauf qu'il mesure le temps en unités de graduations de la minuterie des performances système, plutôt qu'en unités de 100 nanosecondes.

Formule : (1- ((N 1 - N 0) / (D 1 - D 0))) x 100, où le numérateur représente le temps au cours de l'intervalle où les composants surveillés étaient inactifs et le dénominateur représente le temps total écoulé de l'intervalle échantillon.

CountPerTimeInterval32Compteur de moyenne conçu pour surveiller la longueur moyenne d'une file d'attente vers une ressource dans le temps. Il affiche la différence entre les longueurs de file d'attente observées au cours des deux derniers intervalles échantillons divisée par la durée de l'intervalle. Ce type de compteur est généralement utilisé pour assurer le suivi du nombre d'éléments en attente ou mis en file d'attente.

Formule : (N 1 - N 0) / (D 1 - D 0), où le numérateur représente le nombre d'éléments de la file d'attente et le dénominateur représente le temps écoulé au cours du dernier intervalle échantillon.

CountPerTimeInterval64Compteur de moyenne qui surveille la longueur moyenne d'une file d'attente vers une ressource dans le temps. Les compteurs de ce type affichent la différence entre les longueurs de file d'attente observées au cours des deux derniers intervalles échantillons divisée par la durée de l'intervalle. Ce type de compteur est identique à CountPerTimeInterval32, sauf qu'il utilise des champs plus étendus afin de contenir des valeurs plus élevées. Ce type de compteur est généralement utilisé pour assurer le suivi d'un grand volume ou d'un très grand nombre d'éléments en attente ou mis en file d'attente.

Formule : (N 1 - N 0) / (D 1 - D 0), où le numérateur représente le nombre d'éléments d'une file d'attente et le dénominateur représente le temps écoulé au cours du dernier intervalle échantillon.

ElapsedTimeMinuterie de différence qui affiche le temps total écoulé entre le démarrage du composant ou du processus et l'heure à laquelle cette valeur est calculée.

Formule : (D 0 - N 0) / F, où D 0 représente l'heure actuelle, N 0 représente l'heure à laquelle l'objet a été démarré, et F représente le nombre d'unités de temps écoulées en une seconde. La valeur de F est factorisée dans l'équation de sorte que le résultat puisse être affiché en secondes.

Les compteurs de ce type comprennent Système\ Temps d'activité système.

NumberOfItems32Compteur instantané qui affiche la dernière valeur observée. Utilisé, par exemple, pour gérer un nombre simple d'éléments ou d'opérations.

Formule : aucune. N'affiche pas de moyenne, mais les données brutes telles qu'elles sont recueillies.

Les compteurs de ce type comprennent Mémoire\Octets disponibles.

NumberOfItems64Compteur instantané qui affiche la dernière valeur observée. Utilisé, par exemple, pour maintenir un simple décompte d'une très grande quantité d'éléments ou d'opérations. Identique à NumberOfItems32, sauf qu'il utilise des champs plus étendus afin de contenir des valeurs plus élevées.

Formule : aucune. N'affiche pas de moyenne, mais les données brutes telles qu'elles sont recueillies.

NumberOfItemsHEX32Compteur instantané qui affiche la dernière valeur observée au format hexadécimal. Utilisé, par exemple, pour gérer un nombre simple d'éléments ou d'opérations.

Formule : aucune. N'affiche pas de moyenne, mais les données brutes telles qu'elles sont recueillies.

NumberOfItemsHEX64Compteur instantané qui affiche la dernière valeur observée. Utilisé, par exemple, pour maintenir un simple décompte d'une très grande quantité d'éléments ou d'opérations. Identique à NumberOfItemsHEX32, sauf qu'il utilise des champs plus étendus afin de contenir des valeurs plus élevées.

Formule : aucune. N'affiche pas de moyenne, mais les données brutes telles qu'elles sont recueillies.

RateOfCountsPerSecond32Compteur de différence qui affiche le nombre moyen d'opérations exécutées au cours de chaque seconde de l'intervalle échantillon. Les compteurs de ce type mesurent le temps en graduations de l'horloge système.

Formule: (N 1 -N 0) / ((D 1 -D 0) / F), où N 1 et N 0 sont des valeurs du compteur de performance, et où D 1 et D 0 sont leurs valeurs temporelles correspondantes, et où F représente le nombre de graduations par seconde. Par conséquent, le numérateur représente le nombre d'opérations exécutées au cours du dernier intervalle échantillon, le dénominateur représente le nombre de graduations écoulées au cours du dernier intervalle échantillon, et F représente la fréquence des graduations. La valeur de F est factorisée dans l'équation de sorte que le résultat puisse être affiché en secondes.

Les compteurs de ce type comprennent Système\ Opérations de lecture de fichier/s.

RateOfCountsPerSecond64Compteur de différence qui affiche le nombre moyen d'opérations exécutées au cours de chaque seconde de l'intervalle échantillon. Les compteurs de ce type mesurent le temps en graduations de l'horloge système. Ce type de compteur est identique au type RateOfCountsPerSecond32, mais il utilise des champs plus étendus afin de contenir des valeurs plus élevées pour assurer le suivi d'un grand nombre d'éléments ou d'opérations par seconde, tel qu'un taux de transmission d'octets.

Formule: (N 1 -N 0) / ((D 1 -D 0) / F), où N 1 et N 0 sont des valeurs du compteur de performance, et où D 1 et D 0 sont leurs valeurs temporelles correspondantes, et où F représente le nombre de graduations par seconde. Par conséquent, le numérateur représente le nombre d'opérations exécutées au cours du dernier intervalle échantillon, le dénominateur représente le nombre de graduations écoulées au cours du dernier intervalle échantillon, et F représente la fréquence des graduations. La valeur de F est factorisée dans l'équation de sorte que le résultat puisse être affiché en secondes.

Les compteurs de ce type comprennent Système\ Octets lus sur fichier/s.

RawBaseCompteur de base qui contient le dénominateur d'un compteur présentant une fraction arithmétique générale. Vérifiez que cette valeur est supérieure à zéro avant de l'utiliser comme dénominateur dans un calcul de valeur RawFraction.
RawFractionCompteur de pourcentage instantané qui affiche le rapport entre un sous-ensemble et son ensemble sous forme de pourcentage. Par exemple, il compare le nombre d'octets utilisés sur un disque avec le nombre total d'octets de ce disque. Les compteurs de ce type affichent uniquement le pourcentage actuel, non pas une moyenne dans le temps.

Formule : (N 0 / D 0) x 100, où D 0 représente un attribut mesuré (à l'aide d'un compteur de base du type RawBase), et N 0 représente un composant de cet attribut.

Les compteurs de ce type comprennent Fichier d'échange\Usage maximal.

SampleBaseCompteur de base contenant le nombre d'interruptions d'échantillonnage prises et utilisé comme dénominateur dans la fraction de l'échantillonnage. La fraction de l'échantillonnage est le nombre d'échantillons qui avaient la valeur 1 (ou true) pour une interruption d'échantillon. Vérifiez que cette valeur est supérieure à zéro avant de l'utiliser comme dénominateur dans un calcul de SampleFraction.
SampleCounterCompteur de moyenne qui affiche le nombre moyen d'opérations exécutées en une seconde. Lorsqu'un compteur de ce type échantillonne les données, chaque interruption d'échantillonnage retourne un ou zéro. Les données du compteur sont le nombre de « un » qui ont été échantillonnés. Il mesure le temps en unités de graduations de la minuterie des performances système.

Formule : (N 1 - N 0) / ((D 1 - D 0) / F), où le numérateur (N) représente le nombre d'opérations exécutées, le dénominateur (D) le temps écoulé en unités de graduations de la minuterie des performances système et F le nombre de graduations écoulées en une seconde. F est factorisé dans l'équation de sorte que le résultat puisse être affiché en secondes.

SampleFractionCompteur de pourcentage qui affiche le rapport moyen entre les accès et toutes les opérations au cours des deux derniers intervalles échantillons.

Formule : ((N 1 - N 0) / (D 1 - D 0)) x 100, où le numérateur représente le nombre d'opérations réussies au cours du dernier intervalle échantillon et le dénominateur représente la modification du nombre de toutes les opérations (du type mesuré) exécutées au cours de l'intervalle échantillon, à l'aide de compteurs du type SampleBase.

Les compteurs de ce type comprennent Cache\% Présence des données épinglées.

Timer100NsCompteur de pourcentage qui affiche la durée d'activité d'un composant sous forme de pourcentage du temps total écoulé de l'intervalle échantillon. Il mesure le temps en unités de 100 nanosecondes (ns). Les compteurs de ce type sont conçus pour mesurer l'activité d'un seul composant à la fois.

Formule : (N 1 - N 0) / (D 1 - D 0) x 100, où le numérateur représente les parties de l'intervalle échantillon au cours duquel les composants surveillés étaient actifs et le dénominateur représente le temps total écoulé de l'intervalle échantillon.

Les compteurs de ce type comprennent Processeur\ % Temps utilisateur.

Timer100NsInverseCompteur de pourcentage qui affiche le pourcentage moyen de temps d'activité observé au cours de l'intervalle échantillon.

Il s'agit d'un compteur inverse. Les compteurs de ce type calculent le temps d'activité en mesurant le temps pendant lequel le service était inactif, puis en soustrayant le pourcentage de temps d'activité de 100 pour cent.

Formule : (1- ((N 1 - N 0) / (D 1 - D 0))) x 100, où le numérateur représente le temps au cours de l'intervalle où les composants surveillés étaient inactifs et le dénominateur représente le temps total écoulé de l'intervalle échantillon.

Les compteurs de ce type comprennent Processeur\ % Temps processeur.

Certains types de compteurs représentent des données brutes, alors que d'autres représentent des valeurs calculées qui se basent sur un ou plusieurs échantillons de compteurs. Les catégories suivantes classent les types de compteurs disponibles.

  • Moyenne : mesurent une valeur dans le temps et affichent la moyenne des deux dernières mesures. Un compteur de base associé à chaque compteur de moyenne assure le suivi du nombre d'échantillons impliqués.

  • Différence : soustraient la dernière mesure de la précédente et affichent la différence si celle-ci est positive. Si elle est négative, ces compteurs affichent un zéro.

  • Instantané : affichent la mesure la plus récente.

  • Pourcentage : affichent les valeurs calculées sous forme de pourcentage.

  • Taux : échantillonnent un nombre croissant d'événements dans le temps et divisent la variation en valeurs de compteur par la variation de l'heure afin d'afficher un taux d'activité.

Lors de l'échantillonnage des données du compteur de performance, l'utilisation d'un type de compteur représentant une moyenne peut rendre significatives les valeurs des données brutes. Par exemple, le compteur de données brutes NumberOfItems64 peut exposer des données relativement aléatoires d'un échantillon à l'autre. La formule de calcul de la moyenne des valeurs retournée par le compteur est (X 0 +X 1 +…+X n)/n, où chaque X i est un échantillon de compteur brut.

Les compteurs de taux sont identiques aux compteurs de moyenne, mais plus appropriés aux situations dans lesquelles le taux augmente proportionnellement à l'utilisation d'une ressource. La formule suivante permet de calculer rapidement la moyenne : ((X n -X 0)/(T n -T 0)) / fréquence, où chaque X i est un échantillon de compteur et chaque T i l'heure à laquelle l'échantillon correspondant a été pris. Le résultat est l'utilisation moyenne par seconde.

RemarqueRemarque

Sauf indication contraire, les secondes constituent la base de temps.

Lors de l'instrumentation d'applications (création et écriture de compteurs de performance personnalisés), vous pourrez être amené à utiliser des types de compteurs de performance qui reposent sur un compteur de base qui leur est associé et qui est utilisé dans les calculs. Le compteur de base doit se trouver immédiatement après le compteur qui lui est associé dans la collection CounterCreationDataCollection utilisée par votre application. Le tableau suivant énumère les types de compteurs de base et les types des compteurs de performance correspondants.

Type du compteur de base

Types des compteurs de performance

AverageBase

AverageTimer32

AverageCount64

CounterMultiBase

CounterMultiTimer

CounterMultiTimerInverse

CounterMultiTimer100Ns

CounterMultiTimer100NsInverse

RawBase

RawFraction

SampleBase

SampleFraction

Les exemples suivants illustrent plusieurs des types de compteurs dans l'énumération PerformanceCounterType.

AverageCount64



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


AverageTimer32



using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Runtime.InteropServices;

public class App
{

    private static PerformanceCounter PC;
    private static PerformanceCounter BPC;

    private const String categoryName = "AverageTimer32SampleCategory";
    private const String counterName = "AverageTimer32Sample";
    private const String baseCounterName = "AverageTimer32SampleBase";

    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(categoryName))
        {

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData averageTimer32 = new CounterCreationData();
            averageTimer32.CounterType = PerformanceCounterType.AverageTimer32;
            averageTimer32.CounterName = counterName;
            CCDC.Add(averageTimer32);

            // Add the base counter.
            CounterCreationData averageTimer32Base = new CounterCreationData();
            averageTimer32Base.CounterType = PerformanceCounterType.AverageBase;
            averageTimer32Base.CounterName = baseCounterName;
            CCDC.Add(averageTimer32Base);

            // Create the category.
            PerformanceCounterCategory.Create(categoryName, 
                "Demonstrates usage of the AverageTimer32 performance counter type", 
                PerformanceCounterCategoryType.SingleInstance, CCDC);

            Console.WriteLine("Category created - " + categoryName);

            return (true);
        }
        else
        {
            Console.WriteLine("Category exists - " + categoryName);
            return (false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counters.
        PC = new PerformanceCounter(categoryName,
                 counterName,
                 false);

        BPC = new PerformanceCounter(categoryName,
            baseCounterName,
            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 i = 0; i < 10; i++)
        {

            PC.RawValue = Stopwatch.GetTimestamp();

            BPC.IncrementBy(10);

            System.Threading.Thread.Sleep(1000);

            Console.WriteLine("Next value = " + PC.NextValue().ToString());
            samplesList.Add(PC.NextSample());

        }

    }

    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 = " +
                CounterSample.Calculate((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]));

        }
    }



    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
    // PERF_AVERAGE_TIMER
    //  Description - This counter type measures the time it takes, on 
    //     average, to complete a process or operation. Counters of this
    //     type display a ratio of the total elapsed time of the sample 
    //     interval to the number of processes or operations completed
    //     during that time. This counter type measures time in ticks 
    //     of the system clock. The F variable represents the number of
    //     ticks per second. The value of F is factored into the equation
    //     so that the result can be displayed in seconds.
    //    
    //  Generic type - Average
    //    
    //  Formula - ((N1 - N0) / F) / (D1 - D0), where the numerator (N)
    //     represents the number of ticks counted during the last 
    //     sample interval, F represents the frequency of the ticks, 
    //     and the denominator (D) represents the number of operations
    //     completed during the last sample interval.
    //    
    //  Average - ((Nx - N0) / F) / (Dx - D0)
    //    
    //  Example - PhysicalDisk\ Avg. Disk sec/Transfer 
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
    private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
    {
        Int64 n1 = s1.RawValue;
        Int64 n0 = s0.RawValue;
        ulong f = (ulong)s1.SystemFrequency;
        Int64 d1 = s1.BaseValue;
        Int64 d0 = s0.BaseValue;

        double numerator = (double)(n1 - n0);
        double denominator = (double)(d1 - d0);
        Single counterValue = (Single)((numerator / f) / denominator);
        return (counterValue);
    }

    // Output information about the counter sample.
    private static void OutputSample(CounterSample s)
    {
        Console.WriteLine("+++++++++++");
        Console.WriteLine("Sample values - \r\n");
        Console.WriteLine("   CounterType      = " + s.CounterType);
        Console.WriteLine("   RawValue         = " + s.RawValue);
        Console.WriteLine("   BaseValue        = " + s.BaseValue);
        Console.WriteLine("   CounterFrequency = " + s.CounterFrequency);
        Console.WriteLine("   CounterTimeStamp = " + s.CounterTimeStamp);
        Console.WriteLine("   SystemFrequency  = " + s.SystemFrequency);
        Console.WriteLine("   TimeStamp        = " + s.TimeStamp);
        Console.WriteLine("   TimeStamp100nSec = " + s.TimeStamp100nSec);
        Console.WriteLine("++++++++++++++++++++++");
    }
}



ElapsedTime



using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Runtime.InteropServices;

public class App 
{

    public static void Main()
    {	
        CollectSamples();
    }


    public static void CollectSamples()
    {
        const String categoryName = "ElapsedTimeSampleCategory";
        const String counterName = "ElapsedTimeSample";

        // 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 ( !PerformanceCounterCategory.Exists(categoryName) ) 
        {

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData ETimeData = new CounterCreationData();
            ETimeData.CounterType = PerformanceCounterType.ElapsedTime;
            ETimeData.CounterName = counterName;
            CCDC.Add(ETimeData);	   
		
            // Create the category.
            PerformanceCounterCategory.Create(categoryName,
                    "Demonstrates ElapsedTime performance counter usage.",
                PerformanceCounterCategoryType.SingleInstance, CCDC);
            // Return, rerun the application to make use of the new counters.
            return;

        }
        else
        {
            Console.WriteLine("Category exists - {0}", categoryName);
        }        

        // Create the performance counter.
        PerformanceCounter PC = new PerformanceCounter(categoryName, 
                                                       counterName, 
                                                       false);
        // Initialize the counter.
        PC.RawValue = Stopwatch.GetTimestamp();

        DateTime Start = DateTime.Now;

        // Loop for the samples.
        for (int j = 0; j < 100; j++) 
        {
            // Output the values.
            if ((j % 10) == 9) 
            {
                Console.WriteLine("NextValue() = " + PC.NextValue().ToString());
                Console.WriteLine("Actual elapsed time = " + DateTime.Now.Subtract(Start).ToString());
                OutputSample(PC.NextSample());
            }

            // Reset the counter on every 20th iteration.
            if (j % 20 == 0)
            {
                PC.RawValue = Stopwatch.GetTimestamp();
                Start = DateTime.Now;
            }
            System.Threading.Thread.Sleep(50);
        }

        Console.WriteLine("Elapsed time = " + DateTime.Now.Subtract(Start).ToString());
    }

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


NumberOfItems32


using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class NumberOfItems64
{

	private static PerformanceCounter PC;

	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("NumberOfItems32SampleCategory") ) 
        {

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData NOI64 = new CounterCreationData();
            NOI64.CounterType = PerformanceCounterType.NumberOfItems64;
            NOI64.CounterName = "NumberOfItems32Sample";
            CCDC.Add(NOI64);

            // Create the category.
            PerformanceCounterCategory.Create("NumberOfItems32SampleCategory",
                "Demonstrates usage of the NumberOfItems32 performance counter type.",
                PerformanceCounterCategoryType.SingleInstance, CCDC);

            return(true);
        }
        else
        {
            Console.WriteLine("Category exists - NumberOfItems32SampleCategory");
            return(false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counter.
        PC = new PerformanceCounter("NumberOfItems32SampleCategory", 
			"NumberOfItems32Sample", 
			false);

        PC.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);

			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]) );

        }
    }
	

	//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
	//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
	private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
	{
		Single counterValue = s1.RawValue;
		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("++++++++++++++++++++++");
	}


	
}


NumberOfItems64


using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class NumberOfItems64
{

	private static PerformanceCounter PC;

	public static void Main()
	{	
		ArrayList samplesList = new ArrayList();

        // If the category does not exist, create the category and exit.
        // Perfomance 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("NumberOfItems64SampleCategory") ) 
		{

			CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

			// Add the counter.
			CounterCreationData NOI64 = new CounterCreationData();
			NOI64.CounterType = PerformanceCounterType.NumberOfItems64;
			NOI64.CounterName = "NumberOfItems64Sample";
			CCDC.Add(NOI64);

			// Create the category.
			PerformanceCounterCategory.Create("NumberOfItems64SampleCategory",
                "Demonstrates usage of the NumberOfItems64 performance counter type.",
                PerformanceCounterCategoryType.SingleInstance, CCDC);
			return(true);
		}
		else
		{
			Console.WriteLine("Category exists - NumberOfItems64SampleCategory");
			return(false);
		}
	}

    private static void CreateCounters()
    {
        // Create the counters.
        PC = new PerformanceCounter("NumberOfItems64SampleCategory", 
            "NumberOfItems64Sample", 
            false);

        PC.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);

            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]) );

		}
	}

	
	//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
	//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
	private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
	{
		Single counterValue = s1.RawValue;
		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("++++++++++++++++++++++");
	}

}


SampleFraction


using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

// Provides a SampleFraction counter to measure the percentage of the user processor 
// time for this process to total processor time for the process.
public class App
{

    private static PerformanceCounter perfCounter;
    private static PerformanceCounter basePerfCounter;
    private static Process thisProcess = Process.GetCurrentProcess();

    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("SampleFractionCategory"))
        {

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData sampleFraction = new CounterCreationData();
            sampleFraction.CounterType = PerformanceCounterType.SampleFraction;
            sampleFraction.CounterName = "SampleFractionSample";
            CCDC.Add(sampleFraction);

            // Add the base counter.
            CounterCreationData sampleFractionBase = new CounterCreationData();
            sampleFractionBase.CounterType = PerformanceCounterType.SampleBase;
            sampleFractionBase.CounterName = "SampleFractionSampleBase";
            CCDC.Add(sampleFractionBase);

            // Create the category.
            PerformanceCounterCategory.Create("SampleFractionCategory",
                "Demonstrates usage of the SampleFraction performance counter type.",
                PerformanceCounterCategoryType.SingleInstance, CCDC);

            return (true);
        }
        else
        {
            Console.WriteLine("Category exists - SampleFractionCategory");
            return (false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counters.

        perfCounter = new PerformanceCounter("SampleFractionCategory",
            "SampleFractionSample",
            false);


        basePerfCounter = new PerformanceCounter("SampleFractionCategory",
            "SampleFractionSampleBase",
            false);


        perfCounter.RawValue = thisProcess.UserProcessorTime.Ticks;
        basePerfCounter.RawValue = thisProcess.TotalProcessorTime.Ticks;
    }
    private static void CollectSamples(ArrayList samplesList)
    {


        // Loop for the samples.
        for (int j = 0; j < 100; j++)
        {

            perfCounter.IncrementBy(thisProcess.UserProcessorTime.Ticks);

            basePerfCounter.IncrementBy(thisProcess.TotalProcessorTime.Ticks);

            if ((j % 10) == 9)
            {
                OutputSample(perfCounter.NextSample());
                samplesList.Add(perfCounter.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 provides A percentage counter that shows the 
    // average ratio of user proccessor time to total processor time  during the last 
    // two sample intervals.
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    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 = 100 * (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("++++++++++++++++++++++");
    }
}


RateOfCountsPerSecond32


using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class App 
{
    private static PerformanceCounter PC;

	public static void Main()
	{	
		ArrayList samplesList = new ArrayList();

        // If the category does not exist, create the category and exit.
        // Perfomance 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("RateOfCountsPerSecond32SampleCategory") ) 
        {


            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData rateOfCounts32 = new CounterCreationData();
            rateOfCounts32.CounterType = PerformanceCounterType.RateOfCountsPerSecond32;
            rateOfCounts32.CounterName = "RateOfCountsPerSecond32Sample";
            CCDC.Add(rateOfCounts32);
	        
             // Create the category.
            PerformanceCounterCategory.Create("RateOfCountsPerSecond32SampleCategory", 
                "Demonstrates usage of the RateOfCountsPerSecond32 performance counter type.",
                PerformanceCounterCategoryType.SingleInstance, CCDC); 
              return(true);
        }
        else
        {
            Console.WriteLine("Category exists - RateOfCountsPerSecond32SampleCategory");
            return(false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counter.
        PC = new PerformanceCounter("RateOfCountsPerSecond32SampleCategory", 
            "RateOfCountsPerSecond32Sample", 
            false);

        PC.RawValue=0;

    }

    private static void CollectSamples(ArrayList samplesList)
    {
	
        Random r = new Random( DateTime.Now.Millisecond );

        // Initialize the performance counter.
        PC.NextSample();

        // Loop for the samples.
        for (int j = 0; j < 100; j++) 
        {
	        
            int value = r.Next(1, 10);
            PC.IncrementBy(value);
            Console.Write(j + " = " + value);

            if ((j % 10) == 9) 
            {
                Console.WriteLine(";       NextValue() = " + PC.NextValue().ToString());
                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]) );


		}
	}


	//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
	//	PERF_COUNTER_COUNTER
	//	Description	 - This counter type shows the average number of operations completed
	//		during each second of the sample interval. Counters of this type
	//		measure time in ticks of the system clock. The F variable represents
	//		the number of ticks per second. The value of F is factored into the
	//		equation so that the result can be displayed in seconds.
	//
    //	Generic type - Difference
	//
	//	Formula - (N1 - N0) / ( (D1 - D0) / F), where the numerator (N) represents the number
	//		of operations performed during the last sample interval, the denominator
	//		(D) represents the number of ticks elapsed during the last sample
	//		interval, and F is the frequency of the ticks.
	//
	//	     Average - (Nx - N0) / ((Dx - D0) / F) 
	//
	//       Example - System\ File Read Operations/sec 
	//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
	private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
	{
		Single numerator = (Single)(s1.RawValue - s0.RawValue);
		Single denomenator = (Single)(s1.TimeStamp - s0.TimeStamp) / (Single)s1.SystemFrequency;
		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("++++++++++++++++++++++");
	}

}



RateOfCountsPerSecond64


using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class App
{
    private static PerformanceCounter PC;

    public static void Main()
    {
        ArrayList samplesList = new ArrayList();

        // If the category does not exist, create the category and exit.
        // Perfomance 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("RateOfCountsPerSecond64SampleCategory"))
        {


            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData rateOfCounts64 = new CounterCreationData();
            rateOfCounts64.CounterType = PerformanceCounterType.RateOfCountsPerSecond64;
            rateOfCounts64.CounterName = "RateOfCountsPerSecond64Sample";
            CCDC.Add(rateOfCounts64);

            // Create the category.
            PerformanceCounterCategory.Create("RateOfCountsPerSecond64SampleCategory",
                "Demonstrates usage of the RateOfCountsPerSecond64 performance counter type.",
                PerformanceCounterCategoryType.SingleInstance, CCDC);
            return (true);
        }
        else
        {
            Console.WriteLine("Category exists - RateOfCountsPerSecond64SampleCategory");
            return (false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counter.
        PC = new PerformanceCounter("RateOfCountsPerSecond64SampleCategory",
            "RateOfCountsPerSecond64Sample",
            false);

        PC.RawValue = 0;

    }

    private static void CollectSamples(ArrayList samplesList)
    {

        Random r = new Random(DateTime.Now.Millisecond);

        // Initialize the performance counter.
        PC.NextSample();

        // Loop for the samples.
        for (int j = 0; j < 100; j++)
        {

            int value = r.Next(1, 10);
            PC.IncrementBy(value);
            Console.Write(j + " = " + value);

            if ((j % 10) == 9)
            {
                Console.WriteLine(";       NextValue() = " + PC.NextValue().ToString());
                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]));


        }
    }

    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    //	PERF_COUNTER_COUNTER
    //	Description	 - This counter type shows the average number of operations completed
    //		during each second of the sample interval. Counters of this type
    //		measure time in ticks of the system clock. The F variable represents
    //		the number of ticks per second. The value of F is factored into the
    //		equation so that the result can be displayed in seconds.
    //
    //	Generic type - Difference
    //
    //	Formula - (N1 - N0) / ( (D1 - D0) / F), where the numerator (N) represents the number
    //		of operations performed during the last sample interval, the denominator
    //		(D) represents the number of ticks elapsed during the last sample
    //		interval, and F is the frequency of the ticks.
    //
    //	Average - (Nx - N0) / ((Dx - D0) / F) 
    //
    //  Example - System\ File Read Operations/sec 
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
    {
        Single numerator = (Single)(s1.RawValue - s0.RawValue);
        Single denomenator = (Single)(s1.TimeStamp - s0.TimeStamp) / (Single)s1.SystemFrequency;
        Single counterValue = numerator / denomenator;
        return (counterValue);
    }

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



RawFraction


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();

        // 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 (SetupCategory())
            return;
        CreateCounters();
        CollectSamples(samplesList);
        CalculateResults(samplesList);
    }

    private static bool SetupCategory()
    {


        if (!PerformanceCounterCategory.Exists("RawFractionSampleCategory"))
        {


            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData rf = new CounterCreationData();
            rf.CounterType = PerformanceCounterType.RawFraction;
            rf.CounterName = "RawFractionSample";
            CCDC.Add(rf);

            // Add the base counter.
            CounterCreationData rfBase = new CounterCreationData();
            rfBase.CounterType = PerformanceCounterType.RawBase;
            rfBase.CounterName = "RawFractionSampleBase";
            CCDC.Add(rfBase);

            // Create the category.
            PerformanceCounterCategory.Create("RawFractionSampleCategory",
                "Demonstrates usage of the RawFraction performance counter type.",
                PerformanceCounterCategoryType.SingleInstance, CCDC);

            return (true);
        }
        else
        {
            Console.WriteLine("Category exists - RawFractionSampleCategory");
            return (false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counters.
        PC = new PerformanceCounter("RawFractionSampleCategory",
            "RawFractionSample",
            false);

        BPC = new PerformanceCounter("RawFractionSampleCategory",
            "RawFractionSampleBase",
            false);

        PC.RawValue = 0;
        BPC.RawValue = 0;
    }

    private static void CollectSamples(ArrayList samplesList)
    {

        Random r = new Random(DateTime.Now.Millisecond);

        // Initialize the performance counter.
        PC.NextSample();

        // Loop for the samples.
        for (int j = 0; j < 100; j++)
        {
            int value = r.Next(1, 10);
            Console.Write(j + " = " + value);

            // Increment the base every time, because the counter measures the number 
            // of high hits (raw fraction value) against all the hits (base value).
            BPC.Increment();

            // Get the % of samples that are 9 or 10 out of all the samples taken.
            if (value >= 9)
                PC.Increment();

            // Copy out the next value every ten times around the loop.
            if ((j % 10) == 9)
            {
                Console.WriteLine(";       NextValue() = " + PC.NextValue().ToString());
                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; i++)
        {
            // Output the sample.
            OutputSample((CounterSample)samplesList[i]);

            // Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " +
                CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i]));

            // Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " +
                MyComputeCounterValue((CounterSample)samplesList[i]));

        }
    }

    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    // Formula from MSDN -
    //      Description - This counter type shows the ratio of a subset to its set as a percentage.
    //			For example, it compares the number of bytes in use on a disk to the
    //			total number of bytes on the disk. Counters of this type display the 
    //			current percentage only, not an average over time.
    //
    // Generic type - Instantaneous, Percentage 
    //	    Formula - (N0 / D0), where D represents a measured attribute and N represents one
    //			component of that attribute.
    //
    //		Average - SUM (N / D) /x 
    //		Example - Paging File\% Usage Peak
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    private static Single MyComputeCounterValue(CounterSample rfSample)
    {
        Single numerator = (Single)rfSample.RawValue;
        Single denomenator = (Single)rfSample.BaseValue;
        Single counterValue = (numerator / denomenator) * 100;
        return (counterValue);
    }

    // Output information about the counter sample.
    private static void OutputSample(CounterSample s)
    {
        Console.WriteLine("+++++++++++");
        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

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft