PerformanceCounter Classe
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Rappresenta un componente del contatore delle prestazioni di 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- Ereditarietà
- Implementazioni
Esempio
Nell'esempio PerformanceCounter di codice seguente viene illustrato l'uso della classe per creare e usare un AverageCount64 tipo di contatore. L'esempio crea categorie, configura i contatori, raccoglie i dati dai contatori e chiama la CounterSampleCalculator classe per interpretare i dati del contatore delle prestazioni. I risultati intermedi e finali vengono visualizzati nella finestra della console. Per altri esempi di altri tipi di contatori delle prestazioni, vedere l'enumerazione 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
Commenti
Il PerformanceCounter componente può essere usato per leggere i contatori predefiniti o personalizzati esistenti e la pubblicazione (scrittura) dei dati sulle prestazioni nei contatori personalizzati.
Nella finestra di dialogo Aggiungi contatori di Windows Monitor prestazioni sono elencati numerosi contatori predefiniti. Per informazioni sui contatori delle prestazioni di .NET Framework, vedere Contatori delle prestazioni.
Il tipo implementa l'interfaccia IDisposable. Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try/catch. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic. Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nell'argomento relativo all'interfaccia IDisposable.
Importante
Nelle versioni 1.0 e 1.1 di .NET Framework, questa classe richiede l'attendibilità completa dei chiamanti immediati. A partire da .NET Framework versione 2.0, questa classe richiede azioni PerformanceCounterPermission specifiche. È consigliabile PerformanceCounterPermission non concedere codice semi-attendibile. La possibilità di leggere e scrivere contatori delle prestazioni consente al codice di eseguire azioni, ad esempio l'enumerazione dei processi e l'acquisizione di informazioni su di esse.
Inoltre, il passaggio di un oggetto al codice meno attendibile può creare un PerformanceCounter problema di sicurezza. Non passare mai oggetti contatori delle prestazioni, ad esempio un PerformanceCounterCategory oggetto o PerformanceCounter, a codice meno attendibile.
Per leggere da un contatore delle prestazioni, creare un'istanza della PerformanceCounter classe, impostare , e, facoltativamente, le CategoryNameInstanceNameCounterNameproprietà o MachineName e quindi chiamare il NextValue metodo per eseguire una lettura del contatore delle prestazioni.
Per pubblicare i dati del contatore delle prestazioni, creare uno o più contatori personalizzati usando il PerformanceCounterCategory.Create metodo, creare un'istanza della PerformanceCounter classe, impostare CategoryNameCounterName l'oggetto e, facoltativamenteInstanceName, o MachineName le proprietà e quindi chiamare , IncrementByIncremento Decrement metodi o impostare la proprietà per modificare il RawValue valore del contatore personalizzato.
Nota
I Incrementmetodi , IncrementBye Decrement usano interlock per aggiornare il valore del contatore. Ciò consente di mantenere accurato il valore del contatore negli scenari multithreading o multiprocesso, ma comporta anche una penalità delle prestazioni. Se non è necessaria l'accuratezza specificata dalle operazioni interlock, è possibile aggiornare la RawValue proprietà direttamente per un massimo di 5 volte il miglioramento delle prestazioni. Tuttavia, negli scenari multithreading alcuni aggiornamenti al valore del contatore potrebbero essere ignorati, causando dati non accurati.
Il contatore è il meccanismo in base al quale vengono raccolti i dati sulle prestazioni. Il Registro di sistema archivia i nomi di tutti i contatori, ognuno dei quali è correlato a un'area specifica della funzionalità del sistema. Gli esempi includono il tempo occupato di un processore, l'utilizzo della memoria o il numero di byte ricevuti tramite una connessione di rete.
Ogni contatore viene identificato in modo univoco tramite il nome e la relativa posizione. Nello stesso modo in cui un percorso di file include un'unità, una directory, una o più sottodirectory e un nome file, le informazioni sui contatori sono costituite da quattro elementi: il computer, la categoria, l'istanza di categoria e il nome del contatore.
Le informazioni sul contatore devono includere la categoria o l'oggetto prestazioni, per cui i dati delle misure contatori per. Le categorie di un computer includono componenti fisici, ad esempio processori, dischi e memoria. Esistono anche categorie di sistema, ad esempio processi e thread. Ogni categoria è correlata a un elemento funzionale all'interno del computer e ha un set di contatori standard assegnati a esso. Questi oggetti sono elencati nell'elenco a discesa Oggetto Prestazioni della finestra di dialogo Aggiungi contatori all'interno del Monitoraggio sistema windows 2000 e è necessario includerli nel percorso del contatore. I dati sulle prestazioni vengono raggruppati in base alla categoria a cui è correlata.
In alcuni casi, possono esistere diverse copie della stessa categoria. Ad esempio, diversi processi e thread vengono eseguiti simultaneamente e alcuni computer contengono più di un processore. Le copie delle categorie sono denominate istanze di categoria e ogni istanza ha un set di contatori standard assegnati a esso. Se una categoria può avere più di un'istanza, è necessario includere una specifica dell'istanza nelle informazioni del contatore.
Per ottenere i dati sulle prestazioni per i contatori che richiedono un valore iniziale o precedente per eseguire il calcolo necessario, chiamare il NextValue metodo due volte e usare le informazioni restituite in base alle esigenze dell'applicazione.
Nota
Le categorie di contatori delle prestazioni installate con .NET Framework 2.0 usano una memoria condivisa separata, con ogni categoria di contatori delle prestazioni con una propria memoria. È possibile specificare le dimensioni della memoria condivisa separata creando un DWORD denominato FileMappingSize nella chiave del Registro di sistema HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<nome> categoria\Prestazioni. Il valore FileMappingSize viene impostato sulle dimensioni della memoria condivisa della categoria. La dimensione predefinita è 131072 decimale. Se il valore FileMappingSize non è presente, viene utilizzato il fileMappingSize valore dell'attributo per l'elemento specificato nel file Machine.config, causando un sovraccarico aggiuntivo per l'elaborazione performanceCounters dei file di configurazione. È possibile ottenere un miglioramento delle prestazioni per l'avvio dell'applicazione impostando le dimensioni del mapping dei file nel Registro di sistema. Per altre informazioni sulle dimensioni del mapping dei file, vedere <performanceCounters>.
Costruttori
| PerformanceCounter() |
Consente di inizializzare una nuova istanza di sola lettura della classe PerformanceCounter, senza associare l'istanza a un contatore di sistema oppure a un contatore delle prestazioni personalizzato. |
| PerformanceCounter(String, String) |
Consente di inizializzare una nuova istanza di sola lettura della classe PerformanceCounter e la associa al contatore di sistema specificato o al contatore delle prestazioni personalizzato sul computer locale. Il costruttore richiede che la categoria abbia una sola istanza. |
| PerformanceCounter(String, String, Boolean) |
Consente di inizializzare una nuova istanza di sola lettura o di lettura e scrittura della classe PerformanceCounter e la associa al contatore di sistema specificato o al contatore delle prestazioni personalizzato sul computer locale. Il costruttore richiede che la categoria contenga una sola istanza. |
| PerformanceCounter(String, String, String) |
Consente di inizializzare una nuova istanza di sola lettura della classe PerformanceCounter e la associa al contatore di sistema specificato o al contatore delle prestazioni personalizzato e all'istanza della categoria sul computer locale. |
| PerformanceCounter(String, String, String, Boolean) |
Consente di inizializzare una nuova istanza di sola lettura o di lettura e scrittura della classe PerformanceCounter e la associa al contatore di sistema specificato o al contatore delle prestazioni personalizzato e all'istanza della categoria sul computer locale. |
| PerformanceCounter(String, String, String, String) |
Consente di inizializzare una nuova istanza di sola lettura della classe PerformanceCounter e la associa al contatore di sistema specificato o al contatore delle prestazioni personalizzato e all'istanza della categoria sul computer specificato. |
Campi
| DefaultFileMappingSize |
Obsoleti.
Obsoleti.
Obsoleti.
Specifica la dimensione, in byte, della memoria globale condivisa dai contatori delle prestazioni. La dimensione predefinita è 524.288 byte. |
Proprietà
| CanRaiseEvents |
Ottiene un valore che indica se il componente può generare un evento. (Ereditato da Component) |
| CategoryName |
Ottiene o imposta il nome della categoria del contatore delle prestazioni di questo contatore. |
| Container |
Ottiene l'oggetto IContainer che contiene Component. (Ereditato da Component) |
| CounterHelp |
Ottiene la descrizione di questo contatore delle prestazioni. |
| CounterName |
Ottiene o imposta il nome del contatore delle prestazioni associato a questa istanza di PerformanceCounter. |
| CounterType |
Ottiene il tipo di contatore del contatore delle prestazioni associato. |
| DesignMode |
Ottiene un valore che indica se il Component si trova in modalità progettazione. (Ereditato da Component) |
| Events |
Ottiene l'elenco dei gestori eventi allegati a questo Component. (Ereditato da Component) |
| InstanceLifetime |
Ottiene o imposta la durata di un processo. |
| InstanceName |
Ottiene o imposta un nome di istanza per questo contatore delle prestazioni. |
| MachineName |
Ottiene o imposta il nome computer per questo contatore delle prestazioni. |
| RawValue |
Ottiene o imposta il valore non elaborato o non calcolato di questo contatore. |
| ReadOnly |
Ottiene o imposta un valore che indica se questa istanza di PerformanceCounter è in modalità di sola lettura. |
| Site |
Ottiene o imposta l'oggetto ISite di Component. (Ereditato da Component) |
Metodi
| BeginInit() |
Avvia l'inizializzazione di un'istanza di PerformanceCounter utilizzata in un form o da un altro componente. L'inizializzazione avviene in fase di esecuzione. |
| Close() |
Chiude il contatore delle prestazioni e libera tutte le risorse assegnate da questa istanza del contatore delle prestazioni. |
| CloseSharedResources() |
Libera lo stato di condiviso della libreria dei contatori prestazioni allocato dai contatori. |
| CreateObjRef(Type) |
Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject) |
| Decrement() |
Decrementa di uno il contatore delle prestazioni associato mediante un'efficace operazione atomica. |
| Dispose() |
Rilascia tutte le risorse usate da Component. (Ereditato da Component) |
| Dispose(Boolean) |
Rilascia le risorse non gestite usate da Component e, facoltativamente, le risorse gestite. (Ereditato da Component) |
| EndInit() |
Termina l'inizializzazione di un'istanza di PerformanceCounter utilizzata in un form o da un altro componente. L'inizializzazione avviene in fase di esecuzione. |
| Equals(Object) |
Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object) |
| GetHashCode() |
Funge da funzione hash predefinita. (Ereditato da Object) |
| GetLifetimeService() |
Obsoleti.
Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject) |
| GetService(Type) |
Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container. (Ereditato da Component) |
| GetType() |
Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object) |
| Increment() |
Incrementa di uno il contatore delle prestazioni associato mediante un'efficace operazione atomica. |
| IncrementBy(Int64) |
Incrementa o decrementa di una quantità specificata il valore del contatore delle prestazioni associato mediante un'efficace operazione atomica. |
| InitializeLifetimeService() |
Obsoleti.
Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject) |
| MemberwiseClone() |
Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object) |
| MemberwiseClone(Boolean) |
Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject) |
| NextSample() |
Recupera un campione del contatore e restituisce il corrispondente valore non elaborato o non calcolato. |
| NextValue() |
Recupera un campione del contatore e restituisce il corrispondente valore calcolato. |
| RemoveInstance() |
Elimina l'istanza della categoria specificata dalla proprietà PerformanceCounter dell'oggetto InstanceName. |
| ToString() |
Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component. Questo metodo non deve essere sottoposto a override. (Ereditato da Component) |
Eventi
| Disposed |
Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose(). (Ereditato da Component) |
