PerformanceCounter Clase
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Representa un componente de contador de rendimiento de 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- Herencia
- Implementaciones
Ejemplos
En el ejemplo de código siguiente se muestra el uso de la PerformanceCounter clase para crear y usar un AverageCount64 tipo de contador. En el ejemplo se crean categorías, se configuran contadores, se recopilan datos de los contadores y se llama a la CounterSampleCalculator clase para interpretar los datos del contador de rendimiento. Los resultados intermedios y finales se muestran en la ventana de la consola. Para obtener ejemplos adicionales de otros tipos de contadores de rendimiento, consulte la PerformanceCounterType enumeración .
#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
Comentarios
El PerformanceCounter componente se puede usar para leer los contadores predefinidos o personalizados existentes y para publicar (escribir) datos de rendimiento en contadores personalizados.
Hay numerosos contadores predefinidos enumerados en el cuadro de diálogo Agregar contadores de Windows Monitor de rendimiento. Para obtener información sobre los contadores de rendimiento de .NET Framework, consulte Contadores de rendimiento.
Este tipo implementa la interfaz IDisposable. Cuando haya terminado de utilizar el tipo, debe desecharlo directa o indirectamente. Para eliminar el tipo directamente, llame a su método Dispose en un bloque try/catch. Para deshacerse de él indirectamente, use una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para más información, vea la sección "Uso de objetos que implementan IDisposable" en el tema de la interfaz IDisposable.
Importante
En las versiones 1.0 y 1.1 de .NET Framework, esta clase requiere que los autores de llamadas inmediatos sean de plena confianza. A partir de .NET Framework versión 2.0, esta clase requiere PerformanceCounterPermission acciones específicas. Se recomienda encarecidamente que PerformanceCounterPermission no se conceda al código de confianza parcial. La capacidad de leer y escribir contadores de rendimiento permite que el código realice acciones como enumerar procesos en ejecución y obtener información sobre ellos.
Además, pasar un PerformanceCounter objeto a código de confianza menor puede crear un problema de seguridad. Nunca pase objetos de contador de rendimiento, como o PerformanceCounterCategoryPerformanceCounter, a código de menor confianza.
Para leer desde un contador de rendimiento, cree una instancia de la PerformanceCounter clase , establezca , CounterNameCategoryNamey, opcionalmente, las InstanceName propiedades o MachineName y, a continuación, llame al NextValue método para realizar una lectura de contador de rendimiento.
Para publicar datos del contador de rendimiento, cree uno o varios contadores personalizados mediante el PerformanceCounterCategory.Create método , cree una instancia de la PerformanceCounter clase , establezca las CategoryNamepropiedades , CounterName y, opcionalmente, o MachineName y, a continuación, InstanceName llame a los IncrementBymétodos , Incremento Decrement o establezca la RawValue propiedad para cambiar el valor del contador personalizado.
Nota:
Los Incrementmétodos , IncrementByy Decrement usan interbloqueos para actualizar el valor del contador. Esto ayuda a mantener el valor de contador preciso en escenarios multiproceso o multiproceso, pero también produce una penalización de rendimiento. Si no necesita la precisión que proporcionan las operaciones interbloqueadas, puede actualizar la RawValue propiedad directamente para una mejora del rendimiento hasta cinco veces. Sin embargo, en escenarios multiproceso, es posible que se omitan algunas actualizaciones del valor del contador, lo que da lugar a datos inexactos.
El contador es el mecanismo por el que se recopilan los datos de rendimiento. El Registro almacena los nombres de todos los contadores, cada uno de los cuales está relacionado con un área específica de la funcionalidad del sistema. Algunos ejemplos son el tiempo ocupado de un procesador, el uso de memoria o el número de bytes recibidos a través de una conexión de red.
Cada contador se identifica de forma única a través de su nombre y su ubicación. De la misma manera que una ruta de acceso de archivo incluye una unidad, un directorio, uno o varios subdirectorios, y un nombre de archivo, la información de contador consta de cuatro elementos: el equipo, la categoría, la instancia de categoría y el nombre del contador.
La información del contador debe incluir la categoría, o el objeto de rendimiento, para el que el contador mide los datos. Las categorías de un equipo incluyen componentes físicos, como procesadores, discos y memoria. También hay categorías del sistema, como procesos y subprocesos. Cada categoría está relacionada con un elemento funcional dentro del equipo y tiene asignado un conjunto de contadores estándar. Estos objetos se muestran en la lista desplegable Objeto de rendimiento del cuadro de diálogo Agregar contadores en el Monitor del sistema de Windows 2000 y debe incluirlos en la ruta de acceso del contador. Los datos de rendimiento se agrupan por la categoría a la que está relacionada.
En algunos casos, pueden existir varias copias de la misma categoría. Por ejemplo, varios procesos y subprocesos se ejecutan simultáneamente y algunos equipos contienen más de un procesador. Las copias de categoría se denominan instancias de categoría y cada instancia tiene asignado un conjunto de contadores estándar. Si una categoría puede tener más de una instancia, se debe incluir una especificación de instancia en la información del contador.
Para obtener los datos de rendimiento de los contadores que requerían un valor inicial o anterior para realizar el cálculo necesario, llame al NextValue método dos veces y use la información devuelta como requiere la aplicación.
Nota:
Las categorías de contadores de rendimiento instaladas con .NET Framework 2.0 usan memoria compartida independiente, con cada categoría de contador de rendimiento con su propia memoria. Puede especificar el tamaño de la memoria compartida independiente creando un DWORD denominado FileMappingSize en la clave del Registro HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\nombre> de< categoría\Rendimiento. El valor FileMappingSize se establece en el tamaño de memoria compartida de la categoría. El tamaño predeterminado es 131072 decimal. Si el valor FileMappingSize no está presente, se usa el fileMappingSize valor de atributo del elemento especificado en el archivo Machine.config, lo que provoca una sobrecarga adicional para el performanceCounters procesamiento de archivos de configuración. Puede obtener una mejora del rendimiento para el inicio de la aplicación estableciendo el tamaño de asignación de archivos en el Registro. Para obtener más información sobre el tamaño de asignación de archivos, consulte <performanceCounters>.
Constructores
| PerformanceCounter() |
Inicializa una nueva instancia de sólo lectura de la clase PerformanceCounter, sin asociar la instancia a ningún contador de rendimiento del sistema o personalizado. |
| PerformanceCounter(String, String) |
Inicializa una nueva instancia de sólo lectura de la clase PerformanceCounter y la asocia al contador de rendimiento personalizado o del sistema especificado en el equipo local. Este constructor precisa que la categoría tenga una sola instancia. |
| PerformanceCounter(String, String, Boolean) |
Inicializa una nueva instancia de sólo lectura o de lectura y escritura de la clase PerformanceCounter y la asocia al contador de rendimiento personalizado o del sistema especificado en el equipo local. Este constructor precisa que la categoría contenga una sola instancia. |
| PerformanceCounter(String, String, String) |
Inicializa una nueva instancia de sólo lectura de la clase PerformanceCounter y la asocia al contador de rendimiento personalizado o del sistema y a la instancia de categoría especificados en el equipo local. |
| PerformanceCounter(String, String, String, Boolean) |
Inicializa una nueva instancia de sólo lectura o de lectura y escritura de la clase PerformanceCounter y la asocia al contador de rendimiento personalizado o del sistema y a la instancia de categoría especificados en el equipo local. |
| PerformanceCounter(String, String, String, String) |
Inicializa una nueva instancia de sólo lectura de la clase PerformanceCounter y la asocia al contador de rendimiento personalizado o del sistema y a la instancia de categoría indicados en el equipo especificado. |
Campos
| DefaultFileMappingSize |
Obsoletos.
Obsoletos.
Obsoletos.
Especifica el tamaño (en bytes) de la memoria global compartida por los contadores de rendimiento. El tamaño predeterminado es de 524.288 bytes. |
Propiedades
| CanRaiseEvents |
Obtiene un valor que indica si el componente puede generar un evento. (Heredado de Component) |
| CategoryName |
Obtiene o establece el nombre de la categoría de contador de rendimiento para este contador de rendimiento. |
| Container |
Obtiene la interfaz IContainer que contiene la clase Component. (Heredado de Component) |
| CounterHelp |
Obtiene la descripción de este contador de rendimiento. |
| CounterName |
Obtiene o establece el nombre del contador de rendimiento asociado a esta instancia de PerformanceCounter. |
| CounterType |
Obtiene el tipo de contador del contador de rendimiento asociado. |
| DesignMode |
Obtiene un valor que indica si Component está actualmente en modo de diseño. (Heredado de Component) |
| Events |
Obtiene la lista de controladores de eventos asociados a Component. (Heredado de Component) |
| InstanceLifetime |
Obtiene o establece el período de duración de un proceso. |
| InstanceName |
Obtiene o establece un nombre de instancia para este contador de rendimiento. |
| MachineName |
Obtiene o establece el nombre de equipo para este contador de rendimiento. |
| RawValue |
Obtiene o establece el valor sin formato o sin calcular de este contador. |
| ReadOnly |
Obtiene o establece un valor que indica si esta instancia de PerformanceCounter está en modo de sólo lectura. |
| Site |
Obtiene o establece ISite de Component. (Heredado de Component) |
Métodos
| BeginInit() |
Activa la inicialización de una instancia de PerformanceCounter que se utiliza en un formulario o que otro componente utiliza. La inicialización se produce en tiempo de ejecución. |
| Close() |
Cierra el contador de rendimiento y libera todos los recursos asignados por esta instancia de contador de rendimiento. |
| CloseSharedResources() |
Libera el estado compartido de la biblioteca de contadores de rendimiento asignado por los contadores. |
| CreateObjRef(Type) |
Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject) |
| Decrement() |
Reduce el valor del contador de rendimiento asociado en uno, mediante una operación atómica eficaz. |
| Dispose() |
Libera todos los recursos que usa Component. (Heredado de Component) |
| Dispose(Boolean) |
Libera los recursos no administrados que usa Component y, de forma opcional, libera los recursos administrados. (Heredado de Component) |
| EndInit() |
Finaliza la inicialización de una instancia de PerformanceCounter que se utiliza en un formulario o en otro componente. La inicialización se produce en tiempo de ejecución. |
| Equals(Object) |
Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object) |
| GetHashCode() |
Sirve como la función hash predeterminada. (Heredado de Object) |
| GetLifetimeService() |
Obsoletos.
Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject) |
| GetService(Type) |
Devuelve un objeto que representa el servicio suministrado por Component o por Container. (Heredado de Component) |
| GetType() |
Obtiene el Type de la instancia actual. (Heredado de Object) |
| Increment() |
Aumenta el valor del contador de rendimiento asociado en uno, mediante una operación atómica eficaz. |
| IncrementBy(Int64) |
Aumenta o reduce el valor del contador de rendimiento asociado en la cantidad especificada mediante una operación atómica eficaz. |
| InitializeLifetimeService() |
Obsoletos.
Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject) |
| MemberwiseClone() |
Crea una copia superficial del Object actual. (Heredado de Object) |
| MemberwiseClone(Boolean) |
Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject) |
| NextSample() |
Obtiene un contador de ejemplo y devuelve su valor sin formato o sin calcular. |
| NextValue() |
Obtiene un contador de ejemplo y devuelve su valor calculado. |
| RemoveInstance() |
Elimina la instancia de categoría especificada por la propiedad PerformanceCounter del objeto InstanceName. |
| ToString() |
Devuelve una String que contiene el nombre del Component, si existe. Este método no se debe invalidar. (Heredado de Component) |
Eventos
| Disposed |
Tiene lugar cuando una llamada elimina el componente mediante una llamada al método Dispose(). (Heredado de Component) |
Se aplica a
Consulte también
Comentarios
Próximamente: a lo largo de 2024, eliminaremos gradualmente los problemas de GitHub como mecanismo de comentarios para el contenido y lo reemplazaremos por un nuevo sistema de comentarios. Para obtener más información, consulte: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de