Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

PerformanceCounter (Clase)

Representa un componente de contador de rendimiento de Windows NT.

Espacio de nombres:  System.Diagnostics
Ensamblado:  System (en System.dll)

'Declaración
<HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization := True,  _
	SharedState := True)> _
Public NotInheritable Class PerformanceCounter _
	Inherits Component _
	Implements ISupportInitialize

El tipo PerformanceCounter expone los siguientes miembros.

  NombreDescripción
Método públicoPerformanceCounterInicializa 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.
Método públicoPerformanceCounter(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.
Método públicoPerformanceCounter(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.
Método públicoPerformanceCounter(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.
Método públicoPerformanceCounter(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.
Método públicoPerformanceCounter(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.
Arriba

  NombreDescripción
Propiedad públicaCategoryNameObtiene o establece el nombre de la categoría de contador de rendimiento para este contador de rendimiento.
Propiedad públicaContainerObtiene IContainer que contiene Component. (Se hereda de Component).
Propiedad públicaCounterHelpObtiene la descripción de este contador de rendimiento.
Propiedad públicaCounterNameObtiene o establece el nombre del contador de rendimiento asociado a esta instancia de PerformanceCounter.
Propiedad públicaCounterTypeObtiene el tipo de contador del contador de rendimiento asociado.
Propiedad públicaInstanceLifetimeObtiene o establece el período de duración de un proceso.
Propiedad públicaInstanceNameObtiene o establece un nombre de instancia para este contador de rendimiento.
Propiedad públicaMachineNameObtiene o establece el nombre de equipo para este contador de rendimiento
Propiedad públicaRawValueObtiene o establece el valor sin formato o sin calcular de este contador.
Propiedad públicaReadOnlyObtiene o establece un valor que indica si esta instancia de PerformanceCounter está en modo de sólo lectura.
Propiedad públicaSiteObtiene o establece ISite de Component. (Se hereda de Component).
Arriba

  NombreDescripción
Método públicoBeginInitActiva 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.
Método públicoCloseCierra el contador de rendimiento y libera todos los recursos asignados por esta instancia de contador de rendimiento.
Método públicoMiembro estáticoCloseSharedResourcesLibera el estado compartido de la biblioteca de contadores de rendimiento asignado por los contadores.
Método públicoCreateObjRefCrea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Se hereda de MarshalByRefObject).
Método públicoDecrementReduce el valor del contador de rendimiento asociado en uno, mediante una operación atómica eficaz.
Método públicoDisposeLibera todos los recursos utilizados por Component. (Se hereda de Component).
Método públicoEndInitFinaliza 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.
Método públicoEquals(Object)Determina si el objeto especificado es igual al objeto actual. (Se hereda de Object).
Método públicoGetHashCode Sirve como una función hash para un tipo en particular. (Se hereda de Object).
Método públicoGetLifetimeServiceRecupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Se hereda de MarshalByRefObject).
Método públicoGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoIncrementAumenta el valor del contador de rendimiento asociado en uno, mediante una operación atómica eficaz.
Método públicoIncrementByAumenta o reduce el valor del contador de rendimiento asociado en la cantidad especificada mediante una operación atómica eficaz.
Método públicoInitializeLifetimeServiceObtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Se hereda de MarshalByRefObject).
Método públicoNextSampleObtiene un contador de ejemplo y devuelve su valor sin formato o sin calcular.
Método públicoNextValueObtiene un contador de ejemplo y devuelve su valor calculado.
Método públicoRemoveInstanceElimina la instancia de categoría especificada por la propiedad InstanceName del objeto PerformanceCounter.
Método públicoToStringDevuelve un objeto String que contiene el nombre del objeto Component, en caso de que exista. Este método no debe reemplazarse. (Se hereda de Component).
Arriba

  NombreDescripción
Evento públicoDisposedSe produce cuando el componente se elimina mediante una llamada al método Dispose. (Se hereda de Component).
Arriba

  NombreDescripción
Campo públicoMiembro estáticoDefaultFileMappingSize Obsoleta. 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.
Arriba

El componente PerformanceCounter se puede utilizar para leer contadores personalizados o contadores predefinidos existentes, y para publicar (escribir) datos de rendimiento en contadores personalizados.

Hay contadores predefinidos numerosos enumerados en el monitor de rendimiento de Windows Cuadro de diálogo agregar contadores. Para obtener información sobre los contadores de rendimiento de .NET Framework, vea Contadores de rendimiento de .NET Framework.

Este tipo implementa la interfaz IDisposable. Cuando haya terminado de utilizar el tipo, se debe eliminar de directa o indirectamente. Para desechar de tipo directamente, llame al método de Dispose en un bloque de try/decatch . Para desechar de indirectamente, utilice una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para obtener más información, vea “Uso de objeto que implementa sección IDisposable” en el tema de la interfaz de IDisposable .

Nota importanteImportante

   En las versiones 1.0 y 1.1 de .NET Framework, esta clase necesita llamadores inmediatos que sean de plena confianza. Al iniciar con la versión 2.0 de .NET Framework, esta clase requiere PerformanceCounterPermission para acciones concretas. Se recomienda encarecidamente que PerformanceCounterPermission no se conceda a código que no sea de plena confianza. 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 objeto de PerformanceCounter al código menos- confirmado puede crear un problema de seguridad. Nunca pase objetos de contador de rendimiento, como PerformanceCounterCategory o PerformanceCounter, a código de menos confianza.

Para leer de un contador de rendimiento, hay que crear una instancia de la clase PerformanceCounter, establecer las propiedades CategoryName, CounterName y, opcionalmente, InstanceName o MachineName, y después llamar al método NextValue para obtener una lectura del contador de rendimiento.

Para publicar datos del contador de rendimiento, hay que crear uno o más contadores personalizados utilizando el método PerformanceCounterCategory.Create, crear una instancia de la clase PerformanceCounter, establecer las propiedades CategoryName, CounterName y, opcionalmente, InstanceName o MachineName, y después llamar a los métodos IncrementBy, Increment o Decrement, o establecer la propiedad RawValue para cambiar el valor del contador personalizado.

NotaNota

Los métodos Increment, IncrementBy y Decrement utilizan interbloqueos para actualizar el valor de contador. Esto ayuda a mantener la precisión del valor de contador en los escenarios multiproceso, pero también produce una reducción del rendimiento. Si no necesita la precisión que proporcionan las operaciones interbloqueadas, puede actualizar la propiedad RawValue directamente y conseguir que el rendimiento mejore hasta 5 veces. Sin embargo, en los escenarios multiproceso, quizás se omitan algunas actualizaciones del valor de contador, produciendo datos inexactos.

El contador es el mecanismo mediante el cual se recopilan datos de rendimiento. El Registro almacena los nombres de todos los contadores, cada uno de los cuales está relacionado con un área de funcionalidad específica del sistema. Entre otros ejemplos, se incluyen el tiempo de ocupación 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 inequívoca mediante su nombre y su ubicación. Del mismo modo que una ruta de acceso a un archivo incluye una unidad, un directorio, uno o más subdirectorios y un nombre de archivo, la información del contador se compone de cuatro elementos: el equipo, la categoría, la instancia de la categoría y el nombre del contador.

La información del contador debe incluir la categoría, o el objeto de rendimiento, cuyos datos mide el contador. Las categorías de un equipo incluyen los componentes físicos, como los procesadores, los discos y la memoria. También hay categorías del sistema, como procesos y subprocesos. Cada categoría está relacionada con un elemento funcional del equipo y tiene asignado un conjunto de contadores estándar. Estos objetos se enumeran en la lista desplegable Objeto de rendimiento del cuadro de diálogo Agregar contadores del Monitor de sistema de Windows 2000 y debe incluirlos en la ruta de acceso del contador. Los datos de rendimiento se agrupan por categorías, en función de la categoría con la que estén relacionados.

En algunos casos, pueden existir varias copias de la misma categoría. Esto se debe, por ejemplo, a que varios procesos y subprocesos se ejecutan simultáneamente y a que algunos equipos contienen más de un procesador. Las copias de categoría se denominan instancias de categoría. Cada instancia tiene asignado un conjunto de contadores estándar. Si una categoría puede contener más de una instancia, es necesario incluir una especificación de instancia en la información del contador.

Para obtener los datos de rendimiento de los contadores que requieren un valor inicial o un valor anterior para realizar los cálculos necesarios, llame al método NextValue dos veces y utilice la información que devuelve en función de las necesidades de la aplicación.

NotaNota

Las categorías de contador de rendimiento instaladas con .NET Framework 2.0 utilizan memoria compartida independiente, y cada categoría de contador de rendimiento tiene su propia memoria. Se 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>\Performance. El valor de FileMappingSize se establece en el tamaño de memoria compartida de la categoría. El tamaño predeterminado es el valor decimal 131072. Si el valor de FileMappingSize no está presente, se utiliza el valor del atributo fileMappingSize para el elemento performanceCounters especificado en el archivo Machine.config, lo que provoca una sobrecarga adicional en el procesamiento del archivo de configuración. Puede apreciar una mejora del rendimiento en 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, vea <performanceCounters> (Elemento).

NotaNota

El atributo HostProtectionAttribute aplicado a este tipo o miembro tiene el siguiente valor de propiedad Resources: Synchronization | SharedState. El atributo HostProtectionAttribute no afecta a las aplicaciones de escritorio (que normalmente se inician haciendo doble clic en un icono, escribiendo un comando o introduciendo una dirección URL en el explorador). Para obtener más información, vea la clase HostProtectionAttribute o Programación en SQL Server y atributos de protección de host.

Nota de la plataforma : Los contadores de rendimiento no son compatibles con Windows 98 y Windows Millennium Edition (Me).

En el siguiente ejemplo de código se muestra el uso de la clase PerformanceCounter para crear y usar un tipo de contador AverageCount64. El ejemplo crea las categorías, configura los contadores, recopila los datos de los contadores y llama a la clase CounterSampleCalculator para interpretar los datos del contador de rendimiento. Los resultados intermedio y final se muestran en la ventana de la consola. Para obtener ejemplos adicionales de otros tipos de contador de rendimiento, vea la enumeración PerformanceCounterType.


Imports System
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 'Main



    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 'CreateCounters

    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 'CollectSamples

    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 'CalculateResults




    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '	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 'OutputSample
End Class 'App


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft