PerformanceCounter Clase

Definición

Representa un componente de contador de rendimiento de Windows NT.Represents a Windows NT performance counter component.

public ref class PerformanceCounter sealed : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize
public sealed class PerformanceCounter : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize
type PerformanceCounter = class
    inherit Component
    interface ISupportInitialize
Public NotInheritable Class PerformanceCounter
Inherits Component
Implements ISupportInitialize
Herencia
PerformanceCounter
Implementaciones

Ejemplos

En el ejemplo de código siguiente se muestra el uso de la clase PerformanceCounter para crear y usar un tipo de contador AverageCount64.The following code example demonstrates the use of the PerformanceCounter class to create and use an AverageCount64 counter type. En el ejemplo se crean categorías, se configuran contadores, se recopilan datos de los contadores y se llama a la clase CounterSampleCalculator para interpretar los datos del contador de rendimiento.The example creates categories, sets up counters, collects data from the counters, and calls the CounterSampleCalculator class to interpret the performance counter data. Los resultados intermedios y finales se muestran en la ventana de la consola.The intermediate and final results are displayed in the console window. Para obtener más ejemplos de otros tipos de contadores de rendimiento, vea la enumeración PerformanceCounterType.For additional examples of other performance counter types, see the PerformanceCounterType enumeration.

#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 componente de PerformanceCounter se puede usar para leer contadores predefinidos o personalizados existentes y publicar (escribir) datos de rendimiento en contadores personalizados.The PerformanceCounter component can be used for both reading existing predefined or custom counters and publishing (writing) performance data to custom counters.

Hay numerosos contadores predefinidos enumerados en el cuadro de diálogo Agregar contadoresdel monitor de rendimiento de Windows.There are numerous predefined counters listed in the Windows Performance Monitor's Add Counters dialog box. Para obtener información sobre los contadores de rendimiento de .NET Framework, vea contadores de rendimiento.To learn about the .NET Framework performance counters, see Performance Counters.

Este tipo implementa la interfaz IDisposable.This type implements the IDisposable interface. Cuando haya terminado de utilizar el tipo, debe desecharlo directa o indirectamente.When you have finished using the type, you should dispose of it either directly or indirectly. Para eliminar el tipo directamente, llame a su método Dispose en un bloque try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Para deshacerse de él indirectamente, use una construcción de lenguaje como using (en C#) o Using (en Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Para más información, vea la sección "Uso de objetos que implementan IDisposable" en el tema de la interfaz IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Importante

En las versiones 1,0 y 1,1 del .NET Framework, esta clase requiere que los llamadores inmediatos sean de plena confianza.In versions 1.0 and 1.1 of the .NET Framework, this class requires immediate callers to be fully trusted. A partir de la versión 2,0 de .NET Framework, esta clase requiere PerformanceCounterPermission para acciones específicas.Starting with the .NET Framework version 2.0, this class requires PerformanceCounterPermission for specific actions. Se recomienda encarecidamente que PerformanceCounterPermission no se concedan al código de confianza parcial.It is strongly recommended that PerformanceCounterPermission not be granted to semi-trusted code. La capacidad de leer y escribir contadores de rendimiento permite que el código realice acciones como enumerar los procesos de ejecución y obtener información sobre ellos.The ability to read and write performance counters allows code to perform actions such as enumerating executing processes and obtaining information about them.

Además, el paso de un objeto de PerformanceCounter a código de menos confianza puede crear un problema de seguridad.In addition, passing a PerformanceCounter object to less-trusted code can create a security issue. Nunca pase objetos de contador de rendimiento, como un PerformanceCounterCategory o PerformanceCounter, a código de menos confianza.Never pass performance counter objects, such as a PerformanceCounterCategory or PerformanceCounter, to less trusted code.

Para leer de un contador de rendimiento, cree una instancia de la clase PerformanceCounter, establezca el CategoryName, CounterNamey, opcionalmente, las propiedades InstanceName o MachineName y, a continuación, llame al método NextValue para realizar una lectura del contador de rendimiento.To read from a performance counter, create an instance of the PerformanceCounter class, set the CategoryName, CounterName, and, optionally, the InstanceName or MachineName properties, and then call the NextValue method to take a performance counter reading.

Para publicar datos de contadores de rendimiento, cree uno o varios contadores personalizados mediante el método PerformanceCounterCategory.Create, cree una instancia de la clase PerformanceCounter, establezca las propiedades CategoryName, CounterName y, opcionalmente, InstanceName o MachineName y, a continuación, llame a los métodos IncrementBy, Incremento Decrement, o establezca la propiedad RawValue para cambiar el valor del contador personalizado.To publish performance counter data, create one or more custom counters using the PerformanceCounterCategory.Create method, create an instance of the PerformanceCounter class, set the CategoryName, CounterName and, optionally, InstanceName or MachineName properties, and then call the IncrementBy, Increment, or Decrement methods, or set the RawValue property to change the value of your custom counter.

Nota

Los métodos Increment, IncrementByy Decrement usan interbloqueos para actualizar el valor del contador.The Increment, IncrementBy, and Decrement methods use interlocks to update the counter value. Esto ayuda a mantener la precisión del valor de contador en escenarios multiproceso o multiproceso, pero también produce una reducción del rendimiento.This helps keep the counter value accurate in multithreaded or multiprocess scenarios, but also results in a performance penalty. Si no necesita la precisión que proporcionan las operaciones de interbloqueo, puede actualizar la propiedad RawValue directamente para una mejora de rendimiento de hasta cinco veces.If you do not need the accuracy that interlocked operations provide, you can update the RawValue property directly for up to a 5 times performance improvement. Sin embargo, en escenarios multiproceso, es posible que se omitan algunas actualizaciones en el valor del contador, lo que da lugar a datos inexactos.However, in multithreaded scenarios, some updates to the counter value might be ignored, resulting in inaccurate data.

El contador es el mecanismo por el que se recopilan los datos de rendimiento.The counter is the mechanism by which performance data is collected. El registro almacena los nombres de todos los contadores, cada uno de los cuales está relacionado con un área específica de funcionalidad del sistema.The registry stores the names of all the counters, each of which is related to a specific area of system functionality. Entre los ejemplos se incluye el tiempo ocupado del procesador, el uso de memoria o el número de bytes recibidos a través de una conexión de red.Examples include a processor's busy time, memory usage, or the number of bytes received over a network connection.

Cada contador se identifica de forma única a través de su nombre y su ubicación.Each counter is uniquely identified through its name and its location. Del mismo modo que una ruta de acceso de archivo incluye una unidad, un directorio, uno o varios subdirectorios y un nombre de archivo, la información del contador consta de cuatro elementos: el equipo, la categoría, la instancia de categoría y el nombre del contador.In the same way that a file path includes a drive, a directory, one or more subdirectories, and a file name, counter information consists of four elements: the computer, the category, the category instance, and the counter name.

La información del contador debe incluir la categoría, o el objeto de rendimiento, para el que el contador mide los datos.The counter information must include the category, or performance object, that the counter measures data for. Las categorías de un equipo incluyen componentes físicos, como procesadores, discos y memoria.A computer's categories include physical components, such as processors, disks, and memory. También hay categorías del sistema, como procesos y subprocesos.There are also system categories, such as processes and threads. Cada categoría está relacionada con un elemento funcional del equipo y tiene un conjunto de contadores estándar asignados.Each category is related to a functional element within the computer and has a set of standard counters assigned to it. Estos objetos se muestran en la lista desplegable de objetos rendimiento del cuadro de diálogo Agregar contadores en el monitor de sistema de Windows 2000 y debe incluirlos en la ruta de acceso del contador.These objects are listed in the Performance object drop-down list of the Add Counters dialog box within the Windows 2000 System Monitor, and you must include them in the counter path. Los datos de rendimiento se agrupan por la categoría a la que está relacionado.Performance data is grouped by the category to which is it related.

En algunos casos, pueden existir varias copias de la misma categoría.In certain cases, several copies of the same category can exist. Por ejemplo, varios procesos y subprocesos se ejecutan simultáneamente y algunos equipos contienen más de un procesador.For example, several processes and threads run simultaneously, and some computers contain more than one processor. Las copias de categoría se denominan instancias de categoría y cada instancia tiene un conjunto de contadores estándar asignados a ella.The category copies are called category instances, and each instance has a set of standard counters assigned to it. 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.If a category can have more than one instance, an instance specification must be included in the counter information.

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 método NextValue dos veces y use la información que se devuelve cuando la aplicación lo requiera.To obtain performance data for counters that required an initial or previous value for performing the necessary calculation, call the NextValue method twice and use the information returned as your application requires.

Nota

Las categorías de contadores de rendimiento instaladas con el .NET Framework 2.0.NET Framework 2.0 usar una memoria compartida independiente, con cada categoría de contador de rendimiento que tiene su propia memoria.Performance counter categories installed with the .NET Framework 2.0.NET Framework 2.0 use separate shared memory, with each performance counter category having its own memory. Puede especificar el tamaño de la memoria compartida independiente mediante la creación de un valor DWORD denominado FileMappingSize en la clave del registro HKEY_LOCAL_MACHINE \SYSTEM\CurrentControlSet\Services\<nombre de categoría > \Performance.You can specify the size of separate shared memory by creating a DWORD named FileMappingSize in the registry key HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<category name> \Performance. El valor FileMappingSize se establece en el tamaño de la memoria compartida de la categoría.The FileMappingSize value is set to the shared memory size of the category. El tamaño predeterminado es 131072 decimal.The default size is 131072 decimal. Si el valor FileMappingSize no está presente, se usa el valor del atributo fileMappingSize para el elemento performanceCounters especificado en el archivo Machine. config, lo que provoca una sobrecarga adicional para el procesamiento del archivo de configuración.If the FileMappingSize value is not present, the fileMappingSize attribute value for the performanceCounters element specified in the Machine.config file is used, causing additional overhead for configuration file processing. Puede realizar una mejora en el rendimiento del inicio de la aplicación si establece el tamaño de asignación de archivos en el registro.You can realize a performance improvement for application startup by setting the file mapping size in the registry. Para obtener más información sobre el tamaño de asignación de archivos, vea <performanceCounters>.For more information about the file mapping size, see <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.Initializes a new, read-only instance of the PerformanceCounter class, without associating the instance with any system or custom performance counter.

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.Initializes a new, read-only instance of the PerformanceCounter class and associates it with the specified system or custom performance counter on the local computer. Este constructor precisa que la categoría tenga una sola instancia.This constructor requires that the category have a single instance.

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.Initializes a new, read-only or read/write instance of the PerformanceCounter class and associates it with the specified system or custom performance counter on the local computer. Este constructor precisa que la categoría contenga una sola instancia.This constructor requires that the category contain a single instance.

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.Initializes a new, read-only instance of the PerformanceCounter class and associates it with the specified system or custom performance counter and category instance on the local computer.

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.Initializes a new, read-only or read/write instance of the PerformanceCounter class and associates it with the specified system or custom performance counter and category instance on the local computer.

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.Initializes a new, read-only instance of the PerformanceCounter class and associates it with the specified system or custom performance counter and category instance, on the specified computer.

Campos

DefaultFileMappingSize

Especifica el tamaño (en bytes) de la memoria global compartida por los contadores de rendimiento.Specifies the size, in bytes, of the global memory shared by performance counters. El tamaño predeterminado es de 524.288 bytes.The default size is 524,288 bytes.

Propiedades

CanRaiseEvents

Obtiene un valor que indica si el componente puede generar un evento.Gets a value indicating whether the component can raise an event.

(Heredado de Component)
CategoryName

Obtiene o establece el nombre de la categoría de contador de rendimiento para este contador de rendimiento.Gets or sets the name of the performance counter category for this performance counter.

Container

Obtiene la interfaz IContainer que contiene la clase Component.Gets the IContainer that contains the Component.

(Heredado de Component)
CounterHelp

Obtiene la descripción de este contador de rendimiento.Gets the description for this performance counter.

CounterName

Obtiene o establece el nombre del contador de rendimiento asociado a esta instancia de PerformanceCounter.Gets or sets the name of the performance counter that is associated with this PerformanceCounter instance.

CounterType

Obtiene el tipo de contador del contador de rendimiento asociado.Gets the counter type of the associated performance counter.

DesignMode

Obtiene un valor que indica si Component está actualmente en modo de diseño.Gets a value that indicates whether the Component is currently in design mode.

(Heredado de Component)
Events

Obtiene la lista de controladores de eventos asociados a Component.Gets the list of event handlers that are attached to this Component.

(Heredado de Component)
InstanceLifetime

Obtiene o establece el período de duración de un proceso.Gets or sets the lifetime of a process.

InstanceName

Obtiene o establece un nombre de instancia para este contador de rendimiento.Gets or sets an instance name for this performance counter.

MachineName

Obtiene o establece el nombre de equipo para este contador de rendimiento.Gets or sets the computer name for this performance counter.

RawValue

Obtiene o establece el valor sin formato, o no calculado, de este contador.Gets or sets the raw, or uncalculated, value of this counter.

ReadOnly

Obtiene o establece un valor que indica si esta instancia de PerformanceCounter está en modo de sólo lectura.Gets or sets a value indicating whether this PerformanceCounter instance is in read-only mode.

Site

Obtiene o establece el ISite de Component.Gets or sets the ISite of the 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.Begins the initialization of a PerformanceCounter instance used on a form or by another component. La inicialización se produce en tiempo de ejecución.The initialization occurs at runtime.

Close()

Cierra el contador de rendimiento y libera todos los recursos asignados por esta instancia de contador de rendimiento.Closes the performance counter and frees all the resources allocated by this performance counter instance.

CloseSharedResources()

Libera el estado compartido de la biblioteca de contadores de rendimiento asignado por los contadores.Frees the performance counter library shared state allocated by the counters.

CreateObjRef(Type)

Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Heredado de MarshalByRefObject)
Decrement()

Reduce el valor del contador de rendimiento asociado en uno, mediante una operación atómica eficaz.Decrements the associated performance counter by one through an efficient atomic operation.

Dispose()

Libera todos los recursos que utiliza Component.Releases all resources used by the Component.

(Heredado de Component)
Dispose(Boolean)

Libera los recursos no administrados utilizados por Component y, opcionalmente, libera también los recursos administrados.Releases the unmanaged resources used by the Component and optionally releases the managed resources.

(Heredado de Component)
EndInit()

Finaliza la inicialización de una instancia de PerformanceCounter que se utiliza en un formulario o en otro componente.Ends the initialization of a PerformanceCounter instance that is used on a form or by another component. La inicialización se produce en tiempo de ejecución.The initialization occurs at runtime.

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
GetHashCode()

Sirve como función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetLifetimeService()

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Heredado de MarshalByRefObject)
GetService(Type)

Devuelve un objeto que representa el servicio suministrado por Component o por Container.Returns an object that represents a service provided by the Component or by its Container.

(Heredado de Component)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
Increment()

Aumenta el valor del contador de rendimiento asociado en uno, mediante una operación atómica eficaz.Increments the associated performance counter by one through an efficient atomic operation.

IncrementBy(Int64)

Aumenta o reduce el valor del contador de rendimiento asociado en la cantidad especificada mediante una operación atómica eficaz.Increments or decrements the value of the associated performance counter by a specified amount through an efficient atomic operation.

InitializeLifetimeService()

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Heredado de MarshalByRefObject)
MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
MemberwiseClone(Boolean)

Crea una copia superficial del objeto MarshalByRefObject actual.Creates a shallow copy of the current MarshalByRefObject object.

(Heredado de MarshalByRefObject)
NextSample()

Obtiene un ejemplo de contador y devuelve un valor sin formato, o no calculado, para él.Obtains a counter sample, and returns the raw, or uncalculated, value for it.

NextValue()

Obtiene un contador de ejemplo y devuelve su valor calculado.Obtains a counter sample and returns the calculated value for it.

RemoveInstance()

Elimina la instancia de categoría especificada por la propiedad PerformanceCounter del objeto InstanceName.Deletes the category instance specified by the PerformanceCounter object InstanceName property.

ToString()

Devuelve una String que contiene el nombre del Component, si existe.Returns a String containing the name of the Component, if any. Este método no se debe invalidar.This method should not be overridden.

(Heredado de Component)

Eventos

Disposed

Tiene lugar cuando una llamada elimina el componente mediante una llamada al método Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Heredado de Component)

Se aplica a

Consulte también: