PerformanceCounter Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Représente un composant de compteur de performances Windows NT.
public ref class PerformanceCounter sealed : System::ComponentModel::Component, System::ComponentModel::ISupportInitializepublic sealed class PerformanceCounter : System.ComponentModel.Component, System.ComponentModel.ISupportInitializetype PerformanceCounter = class
inherit Component
interface ISupportInitializePublic NotInheritable Class PerformanceCounter
Inherits Component
Implements ISupportInitialize- Héritage
- Implémente
Exemples
L’exemple de code suivant illustre l’utilisation de la PerformanceCounter classe pour créer et utiliser un type de AverageCount64 compteur. L’exemple crée des catégories, configure des compteurs, collecte des données à partir des compteurs et appelle la CounterSampleCalculator classe pour interpréter les données du compteur de performances. Les résultats intermédiaires et finaux s’affichent dans la fenêtre de console. Pour obtenir d’autres exemples d’autres types de compteurs de performances, consultez l’énumération PerformanceCounterType .
#using <System.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;
// Output information about the counter sample.
void OutputSample( CounterSample s )
{
Console::WriteLine( "\r\n+++++++++++" );
Console::WriteLine( "Sample values - \r\n" );
Console::WriteLine( " BaseValue = {0}", s.BaseValue );
Console::WriteLine( " CounterFrequency = {0}", s.CounterFrequency );
Console::WriteLine( " CounterTimeStamp = {0}", s.CounterTimeStamp );
Console::WriteLine( " CounterType = {0}", s.CounterType );
Console::WriteLine( " RawValue = {0}", s.RawValue );
Console::WriteLine( " SystemFrequency = {0}", s.SystemFrequency );
Console::WriteLine( " TimeStamp = {0}", s.TimeStamp );
Console::WriteLine( " TimeStamp100nSec = {0}", s.TimeStamp100nSec );
Console::WriteLine( "++++++++++++++++++++++" );
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// Description - This counter type shows how many items are processed, on average,
// during an operation. Counters of this type display a ratio of the items
// processed (such as bytes sent) to the number of operations completed. The
// ratio is calculated by comparing the number of items processed during the
// last interval to the number of operations completed during the last interval.
// Generic type - Average
// Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number
// of items processed during the last sample interval and the denominator (D)
// represents the number of operations completed during the last two sample
// intervals.
// Average (Nx - N0) / (Dx - D0)
// Example PhysicalDisk\ Avg. Disk Bytes/Transfer
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
float MyComputeCounterValue( CounterSample s0, CounterSample s1 )
{
float numerator = (float)s1.RawValue - (float)s0.RawValue;
float denomenator = (float)s1.BaseValue - (float)s0.BaseValue;
float counterValue = numerator / denomenator;
return counterValue;
}
bool SetupCategory()
{
if ( !PerformanceCounterCategory::Exists( "AverageCounter64SampleCategory" ) )
{
CounterCreationDataCollection^ CCDC = gcnew CounterCreationDataCollection;
// Add the counter.
CounterCreationData^ averageCount64 = gcnew CounterCreationData;
averageCount64->CounterType = PerformanceCounterType::AverageCount64;
averageCount64->CounterName = "AverageCounter64Sample";
CCDC->Add( averageCount64 );
// Add the base counter.
CounterCreationData^ averageCount64Base = gcnew CounterCreationData;
averageCount64Base->CounterType = PerformanceCounterType::AverageBase;
averageCount64Base->CounterName = "AverageCounter64SampleBase";
CCDC->Add( averageCount64Base );
// Create the category.
PerformanceCounterCategory::Create( "AverageCounter64SampleCategory", "Demonstrates usage of the AverageCounter64 performance counter type.", CCDC );
return (true);
}
else
{
Console::WriteLine( "Category exists - AverageCounter64SampleCategory" );
return (false);
}
}
void CreateCounters( PerformanceCounter^% PC, PerformanceCounter^% BPC )
{
// Create the counters.
PC = gcnew PerformanceCounter( "AverageCounter64SampleCategory","AverageCounter64Sample",false );
BPC = gcnew PerformanceCounter( "AverageCounter64SampleCategory","AverageCounter64SampleBase",false );
PC->RawValue = 0;
BPC->RawValue = 0;
}
void CollectSamples( ArrayList^ samplesList, PerformanceCounter^ PC, PerformanceCounter^ BPC )
{
Random^ r = gcnew Random( DateTime::Now.Millisecond );
// Loop for the samples.
for ( int j = 0; j < 100; j++ )
{
int value = r->Next( 1, 10 );
Console::Write( "{0} = {1}", j, value );
PC->IncrementBy( value );
BPC->Increment();
if ( (j % 10) == 9 )
{
OutputSample( PC->NextSample() );
samplesList->Add( PC->NextSample() );
}
else
Console::WriteLine();
System::Threading::Thread::Sleep( 50 );
}
}
void CalculateResults( ArrayList^ samplesList )
{
for ( int i = 0; i < (samplesList->Count - 1); i++ )
{
// Output the sample.
OutputSample( *safe_cast<CounterSample^>(samplesList[ i ]) );
OutputSample( *safe_cast<CounterSample^>(samplesList[ i + 1 ]) );
// Use .NET to calculate the counter value.
Console::WriteLine( ".NET computed counter value = {0}", CounterSampleCalculator::ComputeCounterValue( *safe_cast<CounterSample^>(samplesList[ i ]), *safe_cast<CounterSample^>(samplesList[ i + 1 ]) ) );
// Calculate the counter value manually.
Console::WriteLine( "My computed counter value = {0}", MyComputeCounterValue( *safe_cast<CounterSample^>(samplesList[ i ]), *safe_cast<CounterSample^>(samplesList[ i + 1 ]) ) );
}
}
int main()
{
ArrayList^ samplesList = gcnew ArrayList;
PerformanceCounter^ PC;
PerformanceCounter^ BPC;
SetupCategory();
CreateCounters( PC, BPC );
CollectSamples( samplesList, PC, BPC );
CalculateResults( samplesList );
}
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;
public class App
{
private static PerformanceCounter avgCounter64Sample;
private static PerformanceCounter avgCounter64SampleBase;
public static void Main()
{
ArrayList samplesList = new ArrayList();
// If the category does not exist, create the category and exit.
// Performance counters should not be created and immediately used.
// There is a latency time to enable the counters, they should be created
// prior to executing the application that uses the counters.
// Execute this sample a second time to use the category.
if (SetupCategory())
return;
CreateCounters();
CollectSamples(samplesList);
CalculateResults(samplesList);
}
private static bool SetupCategory()
{
if ( !PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") )
{
CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();
// Add the counter.
CounterCreationData averageCount64 = new CounterCreationData();
averageCount64.CounterType = PerformanceCounterType.AverageCount64;
averageCount64.CounterName = "AverageCounter64Sample";
counterDataCollection.Add(averageCount64);
// Add the base counter.
CounterCreationData averageCount64Base = new CounterCreationData();
averageCount64Base.CounterType = PerformanceCounterType.AverageBase;
averageCount64Base.CounterName = "AverageCounter64SampleBase";
counterDataCollection.Add(averageCount64Base);
// Create the category.
PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
"Demonstrates usage of the AverageCounter64 performance counter type.",
PerformanceCounterCategoryType.SingleInstance, counterDataCollection);
return(true);
}
else
{
Console.WriteLine("Category exists - AverageCounter64SampleCategory");
return(false);
}
}
private static void CreateCounters()
{
// Create the counters.
avgCounter64Sample = new PerformanceCounter("AverageCounter64SampleCategory",
"AverageCounter64Sample",
false);
avgCounter64SampleBase = new PerformanceCounter("AverageCounter64SampleCategory",
"AverageCounter64SampleBase",
false);
avgCounter64Sample.RawValue=0;
avgCounter64SampleBase.RawValue=0;
}
private static void CollectSamples(ArrayList samplesList)
{
Random r = new Random( DateTime.Now.Millisecond );
// Loop for the samples.
for (int j = 0; j < 100; j++)
{
int value = r.Next(1, 10);
Console.Write(j + " = " + value);
avgCounter64Sample.IncrementBy(value);
avgCounter64SampleBase.Increment();
if ((j % 10) == 9)
{
OutputSample(avgCounter64Sample.NextSample());
samplesList.Add( avgCounter64Sample.NextSample() );
}
else
{
Console.WriteLine();
}
System.Threading.Thread.Sleep(50);
}
}
private static void CalculateResults(ArrayList samplesList)
{
for(int i = 0; i < (samplesList.Count - 1); i++)
{
// Output the sample.
OutputSample( (CounterSample)samplesList[i] );
OutputSample( (CounterSample)samplesList[i+1] );
// Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " +
CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i+1]) );
// Calculate the counter value manually.
Console.WriteLine("My computed counter value = " +
MyComputeCounterValue((CounterSample)samplesList[i],
(CounterSample)samplesList[i+1]) );
}
}
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
// Description - This counter type shows how many items are processed, on average,
// during an operation. Counters of this type display a ratio of the items
// processed (such as bytes sent) to the number of operations completed. The
// ratio is calculated by comparing the number of items processed during the
// last interval to the number of operations completed during the last interval.
// Generic type - Average
// Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number
// of items processed during the last sample interval and the denominator (D)
// represents the number of operations completed during the last two sample
// intervals.
// Average (Nx - N0) / (Dx - D0)
// Example PhysicalDisk\ Avg. Disk Bytes/Transfer
//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
{
Single numerator = (Single)s1.RawValue - (Single)s0.RawValue;
Single denomenator = (Single)s1.BaseValue - (Single)s0.BaseValue;
Single counterValue = numerator / denomenator;
return(counterValue);
}
// Output information about the counter sample.
private static void OutputSample(CounterSample s)
{
Console.WriteLine("\r\n+++++++++++");
Console.WriteLine("Sample values - \r\n");
Console.WriteLine(" BaseValue = " + s.BaseValue);
Console.WriteLine(" CounterFrequency = " + s.CounterFrequency);
Console.WriteLine(" CounterTimeStamp = " + s.CounterTimeStamp);
Console.WriteLine(" CounterType = " + s.CounterType);
Console.WriteLine(" RawValue = " + s.RawValue);
Console.WriteLine(" SystemFrequency = " + s.SystemFrequency);
Console.WriteLine(" TimeStamp = " + s.TimeStamp);
Console.WriteLine(" TimeStamp100nSec = " + s.TimeStamp100nSec);
Console.WriteLine("++++++++++++++++++++++");
}
}
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
_
Public Class App
Private Shared avgCounter64Sample As PerformanceCounter
Private Shared avgCounter64SampleBase As PerformanceCounter
Public Shared Sub Main()
Dim samplesList As New ArrayList()
'If the category does not exist, create the category and exit.
'Performance counters should not be created and immediately used.
'There is a latency time to enable the counters, they should be created
'prior to executing the application that uses the counters.
'Execute this sample a second time to use the counters.
If Not (SetupCategory()) Then
CreateCounters()
CollectSamples(samplesList)
CalculateResults(samplesList)
End If
End Sub
Private Shared Function SetupCategory() As Boolean
If Not PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") Then
Dim counterDataCollection As New CounterCreationDataCollection()
' Add the counter.
Dim averageCount64 As New CounterCreationData()
averageCount64.CounterType = PerformanceCounterType.AverageCount64
averageCount64.CounterName = "AverageCounter64Sample"
counterDataCollection.Add(averageCount64)
' Add the base counter.
Dim averageCount64Base As New CounterCreationData()
averageCount64Base.CounterType = PerformanceCounterType.AverageBase
averageCount64Base.CounterName = "AverageCounter64SampleBase"
counterDataCollection.Add(averageCount64Base)
' Create the category.
PerformanceCounterCategory.Create("AverageCounter64SampleCategory", _
"Demonstrates usage of the AverageCounter64 performance counter type.", _
PerformanceCounterCategoryType.SingleInstance, counterDataCollection)
Return True
Else
Console.WriteLine("Category exists - AverageCounter64SampleCategory")
Return False
End If
End Function 'SetupCategory
Private Shared Sub CreateCounters()
' Create the counters.
avgCounter64Sample = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64Sample", False)
avgCounter64SampleBase = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64SampleBase", False)
avgCounter64Sample.RawValue = 0
avgCounter64SampleBase.RawValue = 0
End Sub
Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)
Dim r As New Random(DateTime.Now.Millisecond)
' Loop for the samples.
Dim j As Integer
For j = 0 To 99
Dim value As Integer = r.Next(1, 10)
Console.Write(j.ToString() + " = " + value.ToString())
avgCounter64Sample.IncrementBy(value)
avgCounter64SampleBase.Increment()
If j Mod 10 = 9 Then
OutputSample(avgCounter64Sample.NextSample())
samplesList.Add(avgCounter64Sample.NextSample())
Else
Console.WriteLine()
End If
System.Threading.Thread.Sleep(50)
Next j
End Sub
Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
Dim i As Integer
For i = 0 To (samplesList.Count - 1) - 1
' Output the sample.
OutputSample(CType(samplesList(i), CounterSample))
OutputSample(CType(samplesList((i + 1)), CounterSample))
' Use .NET to calculate the counter value.
Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
' Calculate the counter value manually.
Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
Next i
End Sub
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
' Description - This counter type shows how many items are processed, on average,
' during an operation. Counters of this type display a ratio of the items
' processed (such as bytes sent) to the number of operations completed. The
' ratio is calculated by comparing the number of items processed during the
' last interval to the number of operations completed during the last interval.
' Generic type - Average
' Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number
' of items processed during the last sample interval and the denominator (D)
' represents the number of operations completed during the last two sample
' intervals.
' Average (Nx - N0) / (Dx - D0)
' Example PhysicalDisk\ Avg. Disk Bytes/Transfer
'++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
Dim numerator As [Single] = CType(s1.RawValue, [Single]) - CType(s0.RawValue, [Single])
Dim denomenator As [Single] = CType(s1.BaseValue, [Single]) - CType(s0.BaseValue, [Single])
Dim counterValue As [Single] = numerator / denomenator
Return counterValue
End Function 'MyComputeCounterValue
' Output information about the counter sample.
Private Shared Sub OutputSample(ByVal s As CounterSample)
Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
Console.WriteLine((" BaseValue = " + s.BaseValue.ToString()))
Console.WriteLine((" CounterFrequency = " + s.CounterFrequency.ToString()))
Console.WriteLine((" CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
Console.WriteLine((" CounterType = " + s.CounterType.ToString()))
Console.WriteLine((" RawValue = " + s.RawValue.ToString()))
Console.WriteLine((" SystemFrequency = " + s.SystemFrequency.ToString()))
Console.WriteLine((" TimeStamp = " + s.TimeStamp.ToString()))
Console.WriteLine((" TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
Console.WriteLine("++++++++++++++++++++++")
End Sub
End Class
Remarques
Le PerformanceCounter composant peut être utilisé à la fois pour lire des compteurs prédéfinis ou personnalisés existants et pour publier (écrire) des données de performances sur des compteurs personnalisés.
De nombreux compteurs prédéfinis sont répertoriés dans la boîte de dialogue Ajouter des compteurs de Windows Analyseur de performances. Pour en savoir plus sur les compteurs de performances .NET Framework, consultez Compteurs de performances.
Ce type implémente l'interface IDisposable. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement. Pour supprimer directement le type Dispose, appelez sa méthode dans un bloc try/catch. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.
Important
Dans les versions 1.0 et 1.1 de .NET Framework, cette classe nécessite que les appelants immédiats soient entièrement approuvés. À compter de .NET Framework version 2.0, cette classe nécessite PerformanceCounterPermission des actions spécifiques. Il est vivement recommandé de PerformanceCounterPermission ne pas accorder de code semi-approuvé. La possibilité de lire et d’écrire des compteurs de performances permet au code d’effectuer des actions telles que l’énumération des processus en cours d’exécution et l’obtention d’informations sur ceux-ci.
En outre, le passage d’un objet à du PerformanceCounter code moins fiable peut créer un problème de sécurité. Ne passez jamais d’objets de compteur de performances, tels qu’un PerformanceCounterCategory ou PerformanceCounter, à du code moins approuvé.
Pour lire à partir d’un compteur de performances, créez une instance de la PerformanceCounter classe, définissez les CategoryNamepropriétés , CounterNameet, éventuellement, ou InstanceNameMachineName , puis appelez la NextValue méthode pour effectuer une lecture de compteur de performances.
Pour publier des données de compteur de performances, créez un ou plusieurs compteurs personnalisés à l’aide de la PerformanceCounterCategory.Create méthode, créez un instance de la PerformanceCounter classe, définissez les CategoryNamepropriétés etCounterName, éventuellement, InstanceName ou MachineName , puis appelez les IncrementByméthodes , Incrementou Decrement définissez la RawValue propriété pour modifier la valeur de votre compteur personnalisé.
Notes
Les Incrementméthodes , IncrementByet Decrement utilisent des verrous pour mettre à jour la valeur du compteur. Cela permet de maintenir la précision de la valeur du compteur dans les scénarios multithread ou multiprocessus, mais entraîne également une pénalité de performances. Si vous n’avez pas besoin de la précision que fournissent les opérations verrouillées, vous pouvez mettre à jour la RawValue propriété directement pour une amélioration des performances jusqu’à 5 fois. Toutefois, dans les scénarios multithread, certaines mises à jour de la valeur du compteur peuvent être ignorées, ce qui entraîne des données inexactes.
Le compteur est le mécanisme par lequel les données de performances sont collectées. Le Registre stocke les noms de tous les compteurs, chacun d’eux étant lié à une zone spécifique de fonctionnalités système. Par exemple, le temps de travail d’un processeur, l’utilisation de la mémoire ou le nombre d’octets reçus via une connexion réseau.
Chaque compteur est identifié de manière unique par son nom et son emplacement. De la même façon qu’un chemin d’accès de fichier inclut un lecteur, un répertoire, un ou plusieurs sous-répertoires et un nom de fichier, les informations du compteur se composent de quatre éléments : l’ordinateur, la catégorie, la catégorie instance et le nom du compteur.
Les informations du compteur doivent inclure la catégorie, ou l’objet de performance, pour lequel le compteur mesure les données. Les catégories d’un ordinateur incluent les composants physiques, tels que les processeurs, les disques et la mémoire. Il existe également des catégories système, telles que les processus et les threads. Chaque catégorie est liée à un élément fonctionnel au sein de l’ordinateur et a un ensemble de compteurs standard qui lui sont attribués. Ces objets sont répertoriés dans la liste déroulante Objet performance de la boîte de dialogue Ajouter des compteurs dans le Moniteur système Windows 2000, et vous devez les inclure dans le chemin du compteur. Les données de performances sont regroupées par catégorie à laquelle elles sont liées.
Dans certains cas, plusieurs copies de la même catégorie peuvent exister. Par exemple, plusieurs processus et threads s’exécutent simultanément, et certains ordinateurs contiennent plusieurs processeurs. Les copies de catégorie sont appelées instances de catégorie, et chaque instance a un ensemble de compteurs standard qui lui sont attribués. Si une catégorie peut avoir plusieurs instance, une spécification instance doit être incluse dans les informations du compteur.
Pour obtenir des données de performances pour les compteurs qui nécessitaient une valeur initiale ou précédente pour effectuer le calcul nécessaire, appelez la NextValue méthode deux fois et utilisez les informations retournées selon les besoins de votre application.
Notes
Les catégories de compteurs de performances installées avec .NET Framework 2.0 utilisent une mémoire partagée distincte, chaque catégorie de compteurs de performances ayant sa propre mémoire. Vous pouvez spécifier la taille de la mémoire partagée distincte en créant un DWORD nommé FileMappingSize dans la clé de Registre HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<nom> de catégorie\Performance. La valeur FileMappingSize est définie sur la taille de mémoire partagée de la catégorie. La taille par défaut est 131072 décimale. Si la valeur FileMappingSize n’est pas présente, la fileMappingSize valeur d’attribut de l’élément performanceCounters spécifié dans le fichier Machine.config est utilisée, ce qui entraîne une surcharge supplémentaire pour le traitement des fichiers de configuration. Vous pouvez améliorer les performances du démarrage de l’application en définissant la taille du mappage de fichiers dans le Registre. Pour plus d’informations sur la taille du mappage de fichiers, consultez <performanceCounters>.
Constructeurs
| PerformanceCounter() |
Initialise une nouvelle instance en lecture seule de la classe PerformanceCounter, sans associer cette instance à un compteur de performance système ou personnalisé. |
| PerformanceCounter(String, String) |
Initialise une nouvelle instance en lecture seule de la classe PerformanceCounter et l'associe au compteur de performance système ou personnalisé spécifié de l'ordinateur local. Ce constructeur exige que la catégorie ait une seule instance. |
| PerformanceCounter(String, String, Boolean) |
Initialise une nouvelle instance en lecture seule ou en lecture/écriture de la classe PerformanceCounter et l'associe au compteur de performance système ou personnalisé spécifié de l'ordinateur local. Ce constructeur exige que la catégorie contienne une seule instance. |
| PerformanceCounter(String, String, String) |
Initialise une nouvelle instance en lecture seule de la classe PerformanceCounter et l'associe au compteur de performance système ou personnalisé et à l'instance de la catégorie spécifiés sur l'ordinateur local. |
| PerformanceCounter(String, String, String, Boolean) |
Initialise une nouvelle instance en lecture seule ou en lecture/écriture de la classe PerformanceCounter et l'associe au compteur de performance système ou personnalisé et à l'instance de la catégorie spécifiés sur l'ordinateur local. |
| PerformanceCounter(String, String, String, String) |
Initialise une nouvelle instance en lecture seule de la classe PerformanceCounter et l'associe au compteur de performance système ou personnalisé et à l'instance de la catégorie spécifiés sur l'ordinateur donné. |
Champs
| DefaultFileMappingSize |
Obsolète.
Obsolète.
Obsolète.
Spécifie la taille, en octets, de la mémoire globale partagée par les compteurs de performance. La taille par défaut est 524,288 au format décimal. |
Propriétés
| CanRaiseEvents |
Obtient une valeur qui indique si le composant peut déclencher un événement. (Hérité de Component) |
| CategoryName |
Obtient ou définit le nom de la catégorie de compteurs de performance de ce compteur de performance. |
| Container |
Obtient le IContainer qui contient la Component. (Hérité de Component) |
| CounterHelp |
Obtient la description de ce compteur de performance. |
| CounterName |
Obtient ou définit le nom du compteur de performance associé à cette instance de PerformanceCounter. |
| CounterType |
Obtient le type de compteur du compteur de performance associé. |
| DesignMode |
Obtient une valeur qui indique si Component est actuellement en mode design. (Hérité de Component) |
| Events |
Obtient la liste des gestionnaires d'événements attachés à ce Component. (Hérité de Component) |
| InstanceLifetime |
Obtient ou définit la durée de vie d'un processus. |
| InstanceName |
Obtient ou définit un nom d'instance pour ce compteur de performance. |
| MachineName |
Obtient ou définit le nom de l’ordinateur pour ce compteur de performances. |
| RawValue |
Obtient ou définit la valeur brute (ou non calculée) de ce compteur. |
| ReadOnly |
Obtient ou définit une valeur indiquant si cette instance de PerformanceCounter est en mode lecture seule. |
| Site |
Obtient ou définit le ISite de Component. (Hérité de Component) |
Méthodes
| BeginInit() |
Commence l'initialisation d'une instance de PerformanceCounter utilisée dans un formulaire ou par un autre composant. L'initialisation se produit au moment de l'exécution. |
| Close() |
Ferme le compteur de performance et libère toutes les ressources allouées par cette instance du compteur de performance. |
| CloseSharedResources() |
Libère l'état partagé de la bibliothèque de compteurs de performance alloué par les compteurs. |
| CreateObjRef(Type) |
Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant. (Hérité de MarshalByRefObject) |
| Decrement() |
Décrémente d'une unité le compteur de performance associé, à l'aide d'une opération atomique efficace. |
| Dispose() |
Libère toutes les ressources utilisées par Component. (Hérité de Component) |
| Dispose(Boolean) |
Libère les ressources non managées utilisées par Component et libère éventuellement les ressources managées. (Hérité de Component) |
| EndInit() |
Termine l'initialisation d'une instance de PerformanceCounter utilisée dans un formulaire ou par un autre composant. L'initialisation se produit au moment de l'exécution. |
| Equals(Object) |
Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object) |
| GetHashCode() |
Fait office de fonction de hachage par défaut. (Hérité de Object) |
| GetLifetimeService() |
Obsolète.
Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject) |
| GetService(Type) |
Retourne un objet qui représente un service fourni par Component ou par son Container. (Hérité de Component) |
| GetType() |
Obtient le Type de l'instance actuelle. (Hérité de Object) |
| Increment() |
Incrémente d'une unité le compteur de performance associé, à l'aide d'une opération atomique efficace. |
| IncrementBy(Int64) |
Incrémente ou décrémente d'un nombre d'unités spécifique la valeur du compteur de performance associé, à l'aide d'une opération atomique efficace. |
| InitializeLifetimeService() |
Obsolète.
Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject) |
| MemberwiseClone() |
Crée une copie superficielle du Object actuel. (Hérité de Object) |
| MemberwiseClone(Boolean) |
Crée une copie superficielle de l'objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject) |
| NextSample() |
Obtient un échantillon de compteur et retourne sa valeur brute ou non calculée. |
| NextValue() |
Obtient un échantillon de compteur et retourne sa valeur calculée. |
| RemoveInstance() |
Supprime l'instance de la catégorie spécifiée par la propriété PerformanceCounter de l'objet InstanceName. |
| ToString() |
Retourne un String contenant le nom du Component, s’il en existe un. Cette méthode ne doit pas être remplacée. (Hérité de Component) |
Événements
| Disposed |
Se produit lorsque le composant est supprimé par un appel à la méthode Dispose(). (Hérité de Component) |
S’applique à
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour