¿Le resultó útil esta página?
Sus comentarios sobre este contenido son muy importantes. Háganos saber su opinión.
¿Tiene comentarios adicionales?
Caracteres restantes: 1500
Exportar (0) Imprimir
Expandir todo
Expandir Minimizar
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

PerformanceCounterType (Enumeración)

Especifica la fórmula que se utiliza para calcular el método NextValue para una instancia de PerformanceCounter.

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

'Declaración
Public Enumeration PerformanceCounterType

Nombre de miembroDescripción
AverageBaseContador base que se utiliza para calcular el promedio de tiempos o recuentos, como AverageTimer32 y AverageCount64. Almacena el denominador que se utiliza en el cálculo de un contador para presentar el "tiempo por operación" o el "recuento por operación".
AverageCount64Contador de promedio que muestra cuántos elementos se procesan de promedio durante una operación. Los contadores de este tipo muestran la relación entre los elementos procesados y el número de operaciones completadas. Dicha relación se calcula comparando el número de elementos procesados durante el último intervalo con el número de operaciones completadas durante el mismo intervalo.

Fórmula: (N 1 -N 0)/(B 1 -B 0), donde N 1 y N 0 son las lecturas del contador de rendimiento, y B 1 y B 0 son sus valores AverageBase correspondientes. De esta forma, el numerador representa los números de elementos procesados durante el intervalo de la muestra, y el denominador representa el número de operaciones completadas durante ese mismo intervalo.

Entre los contadores de este tipo se encuentra DiscoFísico\ Media de bytes/transferencia.

AverageTimer32Contador de tipo promedio que mide el tiempo transcurrido, de promedio, para completar un proceso u operación. Los contadores de este tipo muestran la relación entre el tiempo total transcurrido del intervalo de muestra y el número de procesos u operaciones completadas durante dicho tiempo. Este tipo de contador mide el tiempo en pasos del reloj del sistema.

Fórmula: ((N 1 -N 0)/F)/(B 1 -B 0), donde N 1 y N 0 son las lecturas del contador de rendimiento, B 1 y B 0 son sus valores AverageBase correspondientes, y F es el número de pasos por segundo. El valor de F se calcula en la ecuación de manera que el resultado se pueda mostrar en segundos. Así, el numerador representa el número de pasos contados durante el último intervalo de muestra, F representa la frecuencia de los pasos y el denominador representa el número de operaciones completadas durante dicho intervalo.

Entre los contadores de este tipo se encuentra DiscoFísico\ Media en segundos/transferencia.

CounterDelta32Contador de diferencia que muestra la variación del atributo medido entre los dos intervalos de muestra más recientes.

Fórmula: N 1 -N 0, donde N 1 y N 0 son las lecturas del contador de rendimiento.

CounterDelta64Contador de diferencia que muestra la variación del atributo medido entre los dos intervalos de muestra más recientes. Es lo mismo que el tipo de contador CounterDelta32, salvo que utiliza campos de mayor tamaño para poder albergar valores más grandes.

Fórmula: N 1 -N 0, donde N 1 y N 0 son las lecturas del contador de rendimiento.

CounterMultiBaseContador base que indica el número de elementos analizados en la muestra. Se utiliza como denominador en los cálculos, para obtener un promedio de los elementos muestreados al tomar mediciones de tiempo de varios elementos similares. Se utiliza con CounterMultiTimer, CounterMultiTimerInverse, CounterMultiTimer100Ns y CounterMultiTimer100NsInverse.
CounterMultiTimerContador de porcentaje que muestra el tiempo activo de uno o más componentes como un porcentaje del tiempo total del intervalo de muestra. Debido a que el numerador registra el tiempo activo de componentes que funcionan simultáneamente, el porcentaje resultante puede superar el 100 por ciento.

Este contador es un temporizador múltiple. Los temporizadores múltiples obtienen datos de más de una instancia de un componente, como un procesador o unidad de disco. Este tipo de contador se diferencia de CounterMultiTimer100Ns en que mide el tiempo en unidades de pasos del contador de rendimiento del sistema, en lugar de unidades de 100 nanosegundos.

Fórmula: ((N 1 - N 0) / (D 1 - D 0)) x 100 / B, donde N 1 y N 0 son lecturas del contador de rendimiento, D 1 y D 0 son las correspondientes lecturas de tiempo en pasos del contador de rendimiento del sistema, y la variable B representa la base de recuento de los componentes supervisados (utilizando un contador base del tipo CounterMultiBase). Así, el numerador representa las partes del intervalo de muestra durante las cuales estaban activos los componentes supervisados, y el denominador representa el tiempo total transcurrido del intervalo de muestra.

CounterMultiTimer100NsContador de porcentaje que muestra el tiempo activo de uno o más componentes como un porcentaje del tiempo total del intervalo de muestra. Mide el tiempo en unidades de 100 nanosegundos (ns).

Este tipo de contador es un temporizador múltiple. Los temporizadores múltiples están diseñados para supervisar más de una instancia de un componente, como un procesador o unidad de disco.

Fórmula: ((N 1 - N 0) / (D 1 - D 0)) x 100 / B, donde N 1 y N 0 son lecturas del contador de rendimiento, D 1 y D 0 son las correspondientes lecturas de tiempo en unidades de 100 nanosegundos, y la variable B representa la base de recuento de los componentes supervisados (utilizando un contador base del tipo CounterMultiBase). Así, el numerador representa las partes del intervalo de muestra durante las cuales estaban activos los componentes supervisados, y el denominador representa el tiempo total transcurrido del intervalo de muestra.

CounterMultiTimer100NsInverseContador de porcentaje que muestra el tiempo activo de uno o más componentes como un porcentaje del tiempo total del intervalo de muestra. Los contadores de este tipo miden el tiempo en unidades de 100 nanosegundos (ns). Derivan el tiempo activo midiendo el tiempo durante el cual los componentes no estaban activos y restándole el resultado de multiplicar 100 por ciento por el número de objetos supervisados.

Este tipo de contador es un temporizador múltiple inverso. Los temporizadores múltiples están diseñados para supervisar más de una instancia de un componente, como un procesador o unidad de disco. Los contadores inversos miden el tiempo en que un componente no está activo y derivan su tiempo activo a partir de la medición del tiempo inactivo.

Fórmula: (B - ((N 1 - N 0) / (D 1 - D 0))) x 100, donde el denominador representa el tiempo total transcurrido del intervalo de muestra, el numerador representa el tiempo del intervalo durante el cual estaban inactivos los componentes supervisados, y B representa el número de componentes supervisados, utilizando un contador base de tipo CounterMultiBase.

CounterMultiTimerInverseContador de porcentaje que muestra el tiempo activo de uno o más componentes como un porcentaje del tiempo total del intervalo de muestra. Deriva el tiempo activo midiendo el tiempo durante el cual los componentes no estaban activos y restándole el resultado de multiplicar 100 por ciento por el número de objetos supervisados.

Este tipo de contador es un temporizador múltiple inverso. Los temporizadores múltiples supervisan más de una instancia de un componente, como un procesador o unidad de disco. Los contadores inversos miden el tiempo en que un componente no está activo y derivan su tiempo activo de dicha medición.

Este contador se diferencia de CounterMultiTimer100NsInverse en que mide el tiempo en unidades de pasos del contador de rendimiento del sistema, en lugar de unidades de 100 nanosegundos.

Fórmula: (B - ((N 1 - N 0) / (D 1 - D 0))) x 100, donde el denominador representa el tiempo total transcurrido del intervalo de muestra, el numerador representa el tiempo del intervalo durante el cual estaban inactivos los componentes supervisados, y B representa el número de componentes supervisados, utilizando un contador base de tipo CounterMultiBase.

CounterTimerContador de porcentaje que muestra el promedio de tiempo que un componente está activo como un porcentaje del tiempo de muestra total.

Fórmula: (N 1 - N 0) / (D 1 - D 0), donde N 1 y N 0 son las lecturas del contador de rendimiento, y D 1 y D 0 son sus correspondientes lecturas de tiempo. Así, el numerador representa las partes del intervalo de muestra durante las cuales estaban activos los componentes supervisados, y el denominador representa el tiempo total transcurrido del intervalo de muestra.

CounterTimerInverseContador de porcentaje que muestra el porcentaje promedio de tiempo activo observado durante el intervalo de muestra. El valor de estos contadores se calcula supervisando el porcentaje de tiempo que el servicio estuvo inactivo y restando ese valor del 100 por ciento.

Este tipo de contador es un contador inverso. Los contadores inversos miden el tiempo en que un componente no está activo y derivan su tiempo activo de dicha medición. Este tipo de contador es igual a CounterTimer100NsInv, excepto en que mide el tiempo en unidades de pasos del contador de rendimiento del sistema, en lugar de unidades de 100 nanosegundos.

Fórmula: (1- ((N 1 - N 0) / (D 1 - D 0))) x 100, donde el numerador representa el tiempo del intervalo durante el cual los componentes supervisados estuvieron inactivos, y el denominador representa el tiempo total transcurrido del intervalo de muestra.

CountPerTimeInterval32Contador de promedio diseñado para supervisar la longitud promedio de la cola de un recurso a lo largo de un determinado período de tiempo. Muestra la diferencia entre las longitudes de cola observadas durante los dos últimos intervalos de muestra, dividida por la duración del intervalo. Este tipo de contador se utiliza normalmente para hacer un seguimiento del número de elementos que están en la cola o a la espera.

Fórmula: (N 1 - N 0) / (D 1 - D 0), donde el numerador representa el número de elementos de la cola y el denominador representa el tiempo transcurrido durante el último intervalo de muestra.

CountPerTimeInterval64Contador de promedio que supervisa la longitud promedio de la cola de un recurso a lo largo de un determinado período de tiempo. Los contadores de este tipo muestran la diferencia entre las longitudes de cola observadas durante los dos últimos intervalos de muestra, dividida por la duración del intervalo. Este tipo de contador es lo mismo que CountPerTimeInterval32, salvo que utiliza campos de mayor tamaño para poder albergar valores más grandes. Este tipo de contador se utiliza normalmente para hacer un seguimiento de un gran volumen o de un número muy elevado de elementos que están en la cola o a la espera.

Fórmula: (N 1 - N 0) / (D 1 - D 0), donde el numerador representa el número de elementos de una cola y el denominador representa el tiempo transcurrido durante el intervalo de muestra.

ElapsedTimeTemporizador de diferencia que muestra el tiempo total transcurrido entre el inicio de un componente o proceso y el momento en que se calcula este valor.

Fórmula: (D 0 - N 0) / F, donde D 0 representa el momento actual, N 0 representa el momento en que se inició el objeto y F representa el número de unidades de tiempo que transcurren en un segundo. El valor de F se calcula en la ecuación de manera que el resultado se pueda mostrar en segundos.

Entre los contadores de este tipo se encuentra Sistema\ Tiempo de actividad del sistema.

NumberOfItems32Contador instantáneo que muestra el valor observado más reciente. Se utiliza, por ejemplo, para mantener un recuento simple de elementos o de operaciones.

Fórmula: ninguna. No muestra un promedio, sino que muestra los datos sin procesar, tal y como se recopilan.

Entre los contadores de este tipo se encuentra Memoria\Bytes disponibles.

NumberOfItems64Contador instantáneo que muestra el valor observado más reciente. Se utiliza, por ejemplo, para mantener un recuento simple de un número muy elevado de elementos o de operaciones. Este tipo de contador es lo mismo que NumberOfItems32, salvo que utiliza campos de mayor tamaño para poder albergar valores más grandes.

Fórmula: ninguna. No muestra un promedio, sino que muestra los datos sin procesar, tal y como se recopilan.

NumberOfItemsHEX32Contador instantáneo que muestra el valor observado más reciente en formato hexadecimal. Se utiliza, por ejemplo, para mantener un recuento simple de elementos o de operaciones.

Fórmula: ninguna. No muestra un promedio, sino que muestra los datos sin procesar, tal y como se recopilan.

NumberOfItemsHEX64Contador instantáneo que muestra el valor observado más reciente. Se utiliza, por ejemplo, para mantener un recuento simple de un número muy elevado de elementos o de operaciones. Este tipo de contador es lo mismo que NumberOfItemsHEX32, salvo que utiliza campos de mayor tamaño para poder albergar valores más grandes.

Fórmula: ninguna. No muestra un promedio, sino que muestra los datos sin procesar, tal y como se recopilan.

RateOfCountsPerSecond32Contador de diferencia que muestra el número promedio de operaciones completadas durante cada segundo del intervalo de muestra. Este tipo de contador mide el tiempo en pasos del reloj del sistema.

Fórmula: (N 1 - N 0) / ((D 1 -D 0) / F), donde N 1 y N 0 son las lecturas del contador de rendimiento, D 1 y D 0 son sus correspondientes lecturas de tiempo, y F representa el número de pasos por segundo. Así, este numerador representa el número de operaciones realizadas durante el último intervalo de muestra, el denominador representa el número de pasos transcurridos desde el último intervalo de muestra y F representa la frecuencia de los pasos. El valor de F se calcula en la ecuación de manera que el resultado se pueda mostrar en segundos.

Entre los contadores de este tipo se encuentra Sistema\ Operaciones de lectura de archivo/s.

RateOfCountsPerSecond64Contador de diferencia que muestra el número promedio de operaciones completadas durante cada segundo del intervalo de muestra. Este tipo de contador mide el tiempo en pasos del reloj del sistema. Este tipo de contador es el mismo que el tipo RateOfCountsPerSecond32, pero utiliza campos más grandes para albergar valores más grandes y así supervisar un alto número de elementos u operaciones por segundo, como por ejemplo una tasa de transmisión de bytes.

Fórmula: (N 1 - N 0) / ((D 1 -D 0) / F), donde N 1 y N 0 son las lecturas del contador de rendimiento, D 1 y D 0 son sus correspondientes lecturas de tiempo, y F representa el número de pasos por segundo. Así, este numerador representa el número de operaciones realizadas durante el último intervalo de muestra, el denominador representa el número de pasos transcurridos desde el último intervalo de muestra y F representa la frecuencia de los pasos. El valor de F se calcula en la ecuación de manera que el resultado se pueda mostrar en segundos.

Entre los contadores de este tipo se encuentra Sistema\ Bytes de lectura de archivo/s.

RawBaseContador base que almacena el denominador de un contador que presenta una fracción aritmética general. Compruebe que este valor es mayor que cero antes de utilizarlo como denominador para calcular el valor RawFraction.
RawFractionContador de porcentaje instantáneo que muestra la relación entre un subconjunto y su conjunto, en porcentaje. Por ejemplo, compara el número de bytes utilizados en un disco con el número total de bytes que contiene el disco. Los contadores de este tipo muestran sólo el porcentaje actual, no un promedio a lo largo del tiempo.

Fórmula: (N 0 / D 0) x 100, donde D 0 representa un atributo medido (utilizando un contador base de tipo RawBase) y N 0 representa un componente de ese atributo.

Entre los contadores de este tipo se encuentra Archivo de paginación\% Uso máximo.

SampleBaseContador base que almacena el número de interrupciones de muestreo tomadas y se utiliza como denominador en la fracción de muestreo. La fracción de muestreo es el número de muestras que dieron 1 (o true) para una interrupción de muestra. Compruebe que este valor es mayor que cero antes de utilizarlo como denominador para calcular SampleFraction.
SampleCounterContador de promedio que muestra el promedio de operaciones completadas en un segundo. Cuando un contador de este tipo toma una muestra de los datos, cada interrupción de muestreo devuelve uno o cero. Los datos del contador son el número de contadores muestreados. Mide el tiempo en unidades de pasos del temporizador de rendimiento del sistema.

Fórmula: (N 1 – N 0) / ((D 1 – D 0) / F), donde el numerador (N) representa el número de operaciones terminadas, el denominador (D) representa el tiempo transcurrido en pasos del temporizador de rendimiento del sistema y F representa el número de pasos que transcurren en un segundo. F se calcula en la ecuación de manera que el resultado se pueda mostrar en segundos.

SampleFractionContador de porcentaje que muestra la relación media entre el número de aciertos y todas las operaciones realizadas durante los dos últimos intervalos de muestra.

Fórmula: ((N 1 - N 0) / (D 1 - D 0)) x 100, donde el numerador representa el número de operaciones satisfactorias durante el último intervalo de muestra, y el denominador representa la variación en el número de todas las operaciones (del tipo medido) completadas durante el intervalo de muestra, utilizando contadores de tipo SampleBase.

Entre los contadores de este tipo se encuentra Caché\% Aciertos de lecturas de anclaje.

Timer100NsContador de porcentaje que muestra el tiempo activo de un componente como un porcentaje del tiempo total transcurrido del intervalo de muestra. Mide el tiempo en unidades de 100 nanosegundos (ns). Los contadores de este tipo están diseñados para medir la actividad de un componente en cada momento.

Fórmula: (N 1 - N 0) / (D 1 - D 0) x 100, donde el numerador representa las partes del intervalo de muestra durante las que los componentes supervisados estuvieron activos, y el denominador representa el tiempo total transcurrido del intervalo de muestra.

Entre los contadores de este tipo se encuentra Procesador\ % de tiempo de usuario.

Timer100NsInverseContador de porcentaje que muestra el porcentaje promedio de tiempo activo observado durante el intervalo de muestra.

Este tipo de contador es un contador inverso. Los contadores de este tipo calculan el tiempo activo midiendo el tiempo que estuvo inactivo el servicio y restando el porcentaje de tiempo activo del 100 por ciento.

Fórmula: (1- ((N 1 - N 0) / (D 1 - D 0))) x 100, donde el numerador representa el tiempo del intervalo durante el cual los componentes supervisados estuvieron inactivos, y el denominador representa el tiempo total transcurrido del intervalo de muestra.

Entre los contadores de este tipo se encuentra Procesador\ % de tiempo de procesador.

Algunos tipos de contador representan datos sin procesar, mientras que otros representan valores calculados que se basan en una o más muestras de contador. Las categorías siguientes clasifican los tipos de contadores disponibles.

  • Average (Promedio): mide un valor a lo largo de un período y muestra el promedio entre las dos últimas mediciones. Se asocia a cada contador de promedio un contador base que registra el número de muestras utilizadas.

  • Difference (Diferencia): resta la última medición de la anterior y muestra la diferencia si es positiva; si es negativa, muestra un cero.

  • Instantaneous (Instantánea): muestra la medición más reciente.

  • Percentage (Porcentaje): muestra los valores calculados como un porcentaje.

  • Rate (Tasa): efectúa una muestra de un número de eventos en aumento a lo largo de un período y divide la variación del número de eventos por la variación en tiempo, lo cual refleja una tasa de actividad.

Al realizar muestreos de datos de contadores de rendimiento, utilizar un tipo de contador que represente un promedio puede hacer que los valores de datos sin procesar resulten de utilidad. Por ejemplo, el contador de datos sin procesar NumberOfItems64 puede exponer datos que sean muy aleatorios entre una muestra y otra. La fórmula para calcular el promedio de valores que el contador devuelve sería (X 0 +X 1 +…+X n)/n, donde cada X i representa una muestra de contador sin formato.

Los contadores de tasa son similares a los contadores de promedio, pero son más útiles en situaciones donde la tasa aumenta a medida que se utiliza un recurso. Una fórmula que calcula rápidamente el promedio es ((X n -X 0)/(T n -T 0)) / frecuencia, donde cada X i es una muestra de contador y cada T i es el tiempo que se tomó la correspondiente muestra. El resultado es el promedio de uso por segundo.

NotaNota

A menos que se indique lo contrario, la base de tiempo se expresa en segundos.

Al instrumentar aplicaciones (crear y escribir contadores de rendimiento personalizados), es posible trabajar con tipos de contador basados en un contador base complementario que se utilice en los cálculos. El contador base debe encontrarse inmediatamente después del contador asociado en la colección CounterCreationDataCollection que utiliza la aplicación. En la siguiente tabla se muestran los tipos de contador base con los tipos de contador de rendimiento correspondientes.

Tipo de contador base

Tipos de contador de rendimiento

AverageBase

AverageTimer32

AverageCount64

CounterMultiBase

CounterMultiTimer

CounterMultiTimerInverse

CounterMultiTimer100Ns

CounterMultiTimer100NsInverse

RawBase

RawFraction

SampleBase

SampleFraction

En los ejemplos siguientes se muestran algunos de los tipos de contador de la enumeración PerformanceCounterType.

AverageCount64


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


AverageTimer32


Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.InteropServices
Imports Microsoft.VisualBasic

Public Class App

    Private Const categoryName As String = "AverageTimer32SampleCategory"
    Private Const counterName As String = "AverageTimer32Sample"
    Private Const baseCounterName As String = "AverageTimer32SampleBase"

    Private Shared PC As PerformanceCounter
    Private Shared BPC As PerformanceCounter


    Public Shared Sub Main()
        Dim samplesList As New ArrayList()

        SetupCategory()
        CreateCounters()
        CollectSamples(samplesList)
        CalculateResults(samplesList)
    End Sub


    Private Shared Function SetupCategory() As Boolean

        If Not PerformanceCounterCategory.Exists(categoryName) Then

            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim averageTimer32 As New CounterCreationData()
            averageTimer32.CounterType = PerformanceCounterType.AverageTimer32
            averageTimer32.CounterName = counterName
            CCDC.Add(averageTimer32)

            ' Add the base counter.
            Dim averageTimer32Base As New CounterCreationData()
            averageTimer32Base.CounterType = PerformanceCounterType.AverageBase
            averageTimer32Base.CounterName = baseCounterName
            CCDC.Add(averageTimer32Base)

            ' Create the category.
            PerformanceCounterCategory.Create( _
               categoryName, _
               "Demonstrates usage of the AverageTimer32 performance counter type", _
                 PerformanceCounterCategoryType.SingleInstance, CCDC)

            Console.WriteLine("Category created - " + categoryName)

            Return True
        Else
            Console.WriteLine(("Category exists - " + _
               categoryName))
            Return False
        End If
    End Function


    Private Shared Sub CreateCounters()
        ' Create the counters.
        PC = New PerformanceCounter(categoryName, _
              counterName, False)

        BPC = New PerformanceCounter(categoryName, _
              baseCounterName, False)

        PC.RawValue = 0
        BPC.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 i As Integer
        For i = 0 To 9

            PC.RawValue = Stopwatch.GetTimeStamp()

            BPC.IncrementBy(10)

            System.Threading.Thread.Sleep(1000)
            Console.WriteLine(("Next value = " + PC.NextValue().ToString()))
            samplesList.Add(PC.NextSample())
        Next i
    End Sub


    Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
        Dim i As Integer
        Dim sample1 As CounterSample
        Dim sample2 As CounterSample
        For i = 0 To (samplesList.Count - 1) - 1
            ' Output the sample.
            sample1 = CType(samplesList(i), CounterSample)
            sample2 = CType(samplesList(i + 1), CounterSample)
            OutputSample(sample1)
            OutputSample(sample2)

            ' Use .NET to calculate the counter value.
            Console.WriteLine((".NET computed counter value = " _
               + CounterSample.Calculate(sample1, sample2).ToString()))

            ' Calculate the counter value manually.
            Console.WriteLine(("My computed counter value = " _
               + MyComputeCounterValue(sample1, sample2).ToString()))

        Next i
    End Sub


    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
    ' PERF_AVERAGE_TIMER
    '  Description - This counter type measures the time it takes, on 
    '     average, to complete a process or operation. Counters of this
    '     type display a ratio of the total elapsed time of the sample 
    '     interval to the number of processes or operations completed
    '     during that time. This counter type measures time in ticks 
    '     of the system clock. The F variable represents the number of
    '     ticks per second. The value of F is factored into the equation
    '     so that the result can be displayed in seconds.
    '
    '  Generic type - Average
    '
    '  Formula - ((N1 - N0) / F) / (D1 - D0), where the numerator (N)
    '     represents the number of ticks counted during the last 
    '     sample interval, F represents the frequency of the ticks, 
    '     and the denominator (D) represents the number of operations
    '     completed during the last sample interval.
    '
    '  Average - ((Nx - N0) / F) / (Dx - D0)
    '
    '  Example - PhysicalDisk\ Avg. Disk sec/Transfer 
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//+++++++
    Private Shared Function MyComputeCounterValue( _
    ByVal s0 As CounterSample, _
    ByVal s1 As CounterSample) As Single
        Dim n1 As Int64 = s1.RawValue
        Dim n0 As Int64 = s0.RawValue
        Dim f As Decimal = CType(s1.SystemFrequency, Decimal)
        Dim d1 As Int64 = s1.BaseValue
        Dim d0 As Int64 = s0.BaseValue

        Dim numerator As Double = System.Convert.ToDouble(n1 - n0)
        Dim denominator As Double = System.Convert.ToDouble(d1 - d0)
        Dim counterValue As Single = CType(numerator, Single)
        counterValue = counterValue / CType(f, Single)
        counterValue = counterValue / CType(denominator, Single)

        Return counterValue
    End Function


    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine("+++++++++++")
        Console.WriteLine("Sample values - " + ControlChars.Cr _
              + ControlChars.Lf)
        Console.WriteLine(("   CounterType      = " + _
              s.CounterType.ToString()))
        Console.WriteLine(("   RawValue         = " + _
              s.RawValue.ToString()))
        Console.WriteLine(("   BaseValue        = " _
              + s.BaseValue.ToString()))
        Console.WriteLine(("   CounterFrequency = " + _
              s.CounterFrequency.ToString()))
        Console.WriteLine(("   CounterTimeStamp = " + _
              s.CounterTimeStamp.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



ElapsedTime



Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics
Imports System.Runtime.InteropServices
Imports Microsoft.VisualBasic

Public Class App

    Public Shared Sub Main()
        CollectSamples()
    End Sub

    Private Shared Sub CollectSamples()

        Dim categoryName As String = "ElapsedTimeSampleCategory"
        Dim counterName As String = "ElapsedTimeSample"

        If Not PerformanceCounterCategory.Exists(categoryName) Then

            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim ETimeData As New CounterCreationData()
            ETimeData.CounterType = PerformanceCounterType.ElapsedTime
            ETimeData.CounterName = counterName
            CCDC.Add(ETimeData)

            ' Create the category.
            PerformanceCounterCategory.Create(categoryName, _
               "Demonstrates ElapsedTime performance counter usage.", _
                   PerformanceCounterCategoryType.SingleInstance, CCDC)

        Else
            Console.WriteLine("Category exists - {0}", categoryName)
        End If

        ' Create the counter.
        Dim PC As PerformanceCounter
        PC = New PerformanceCounter(categoryName, counterName, False)

        ' Initialize the counter.
        PC.RawValue = Stopwatch.GetTimestamp()

        Dim Start As DateTime = DateTime.Now

        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99
            ' Output the values.
            If j Mod 10 = 9 Then
                Console.WriteLine(("NextValue() = " _
                    + PC.NextValue().ToString()))
                Console.WriteLine(("Actual elapsed time = " _
                    + DateTime.Now.Subtract(Start).ToString()))
                OutputSample(PC.NextSample())
            End If

            ' Reset the counter every 20th iteration.
            If j Mod 20 = 0 Then
                PC.RawValue = Stopwatch.GetTimestamp()
                Start = DateTime.Now
            End If
            System.Threading.Thread.Sleep(50)
        Next j

        Console.WriteLine(("Elapsed time = " + _
              DateTime.Now.Subtract(Start).ToString()))
    End Sub


    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++")

        Console.WriteLine("Sample values - " + ControlChars.Cr _
              + ControlChars.Lf)
        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


NumberOfItems32


Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class NumberOfItems64

    Private Shared PC 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("NumberOfItems32SampleCategory") Then

            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim NOI64 As New CounterCreationData()
            NOI64.CounterType = PerformanceCounterType.NumberOfItems64
            NOI64.CounterName = "NumberOfItems32Sample"
            CCDC.Add(NOI64)

            ' Create the category.
            PerformanceCounterCategory.Create("NumberOfItems32SampleCategory", _
            "Demonstrates usage of the NumberOfItems32 performance counter type.", _
                      PerformanceCounterCategoryType.SingleInstance, CCDC)

            Return True
        Else
            Console.WriteLine("Category exists - NumberOfItems32SampleCategory")
            Return False
        End If
    End Function 'SetupCategory


    Private Shared Sub CreateCounters()
        ' Create the counter.
        PC = New PerformanceCounter("NumberOfItems32SampleCategory", "NumberOfItems32Sample", False)

        PC.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())

            PC.IncrementBy(value)

            If j Mod 10 = 9 Then
                OutputSample(PC.NextSample())
                samplesList.Add(PC.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




    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim counterValue As [Single] = s1.RawValue
        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 'NumberOfItems64 




NumberOfItems64


Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class NumberOfItems64

    Private Shared PC 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("NumberOfItems64SampleCategory") Then

            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim NOI64 As New CounterCreationData()
            NOI64.CounterType = PerformanceCounterType.NumberOfItems64
            NOI64.CounterName = "NumberOfItems64Sample"
            CCDC.Add(NOI64)

            ' Create the category.
            PerformanceCounterCategory.Create("NumberOfItems64SampleCategory", _
            "Demonstrates usage of the NumberOfItems64 performance counter type.", _
                   PerformanceCounterCategoryType.SingleInstance, CCDC)

            Return True
        Else
            Console.WriteLine("Category exists - NumberOfItems64SampleCategory")
            Return False
        End If
    End Function 'SetupCategory


    Private Shared Sub CreateCounters()
        ' Create the counters.
        PC = New PerformanceCounter("NumberOfItems64SampleCategory", "NumberOfItems64Sample", False)

        PC.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()))

            PC.IncrementBy(value)

            If j Mod 10 = 9 Then
                OutputSample(PC.NextSample())
                samplesList.Add(PC.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




    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim counterValue As [Single] = s1.RawValue
        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 'NumberOfItems64 


SampleFraction


Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics


' Provides a SampleFraction counter to measure the percentage of the user processor 
' time for this process to total processor time for the process.

Public Class App

    Private Shared perfCounter As PerformanceCounter
    Private Shared basePerfCounter As PerformanceCounter
    Private Shared thisProcess As Process = Process.GetCurrentProcess()


    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 category.
        If SetupCategory() Then
            Return
        End If
        CreateCounters()
        CollectSamples(samplesList)
        CalculateResults(samplesList)

    End Sub 'Main



    Private Shared Function SetupCategory() As Boolean
        If Not PerformanceCounterCategory.Exists("SampleFractionCategory") Then

            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim sampleFraction As New CounterCreationData()
            sampleFraction.CounterType = PerformanceCounterType.SampleFraction
            sampleFraction.CounterName = "SampleFractionSample"
            CCDC.Add(sampleFraction)

            ' Add the base counter.
            Dim sampleFractionBase As New CounterCreationData()
            sampleFractionBase.CounterType = PerformanceCounterType.SampleBase
            sampleFractionBase.CounterName = "SampleFractionSampleBase"
            CCDC.Add(sampleFractionBase)

            ' Create the category.
            PerformanceCounterCategory.Create("SampleFractionCategory", "Demonstrates usage of the SampleFraction performance counter type.", PerformanceCounterCategoryType.SingleInstance, CCDC)

            Return True
        Else
            Console.WriteLine("Category exists - SampleFractionCategory")
            Return False
        End If

    End Function 'SetupCategory


    Private Shared Sub CreateCounters()
        ' Create the counters.
        perfCounter = New PerformanceCounter("SampleFractionCategory", "SampleFractionSample", False)


        basePerfCounter = New PerformanceCounter("SampleFractionCategory", "SampleFractionSampleBase", False)


        perfCounter.RawValue = thisProcess.UserProcessorTime.Ticks
        basePerfCounter.RawValue = thisProcess.TotalProcessorTime.Ticks

    End Sub 'CreateCounters

    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)


        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99

            perfCounter.IncrementBy(thisProcess.UserProcessorTime.Ticks)

            basePerfCounter.IncrementBy(thisProcess.TotalProcessorTime.Ticks)

            If j Mod 10 = 9 Then
                OutputSample(perfCounter.NextSample())
                samplesList.Add(perfCounter.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)
            ' 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)))

            ' Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)))
        Next i

    End Sub 'CalculateResults




    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    ' Description - This counter type provides A percentage counter that shows the 
    ' average ratio of user proccessor time to total processor time  during the last 
    ' two sample intervals.
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    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] = 100 * (numerator / denomenator)
        Return counterValue

    End Function 'MyComputeCounterValue


    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine(vbCr + vbLf + "+++++++++++")
        Console.WriteLine("Sample values - " + vbCr + vbLf)
        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("++++++++++++++++++++++")

    End Sub 'OutputSample
End Class 'App


RateOfCountsPerSecond32


Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class App
    Private Shared PC 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("RateOfCountsPerSecond32SampleCategory") Then


            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim rateOfCounts32 As New CounterCreationData()
            rateOfCounts32.CounterType = PerformanceCounterType.RateOfCountsPerSecond32
            rateOfCounts32.CounterName = "RateOfCountsPerSecond32Sample"
            CCDC.Add(rateOfCounts32)

            ' Create the category.
            PerformanceCounterCategory.Create("RateOfCountsPerSecond32SampleCategory", _
                "Demonstrates usage of the RateOfCountsPerSecond32 performance counter type.", _
                PerformanceCounterCategoryType.SingleInstance, CCDC)
            Return True
        Else
            Console.WriteLine("Category exists - RateOfCountsPerSecond32SampleCategory")
            Return False
        End If
    End Function 'SetupCategory


    Private Shared Sub CreateCounters()
        ' Create the counter.
        PC = New PerformanceCounter("RateOfCountsPerSecond32SampleCategory", "RateOfCountsPerSecond32Sample", False)

        PC.RawValue = 0
    End Sub 'CreateCounters


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

        Dim r As New Random(DateTime.Now.Millisecond)

        ' Initialize the performance counter.
        PC.NextSample()

        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99

            Dim value As Integer = r.Next(1, 10)
            PC.IncrementBy(value)
            Console.Write((j.ToString() + " = " + value.ToString()))

            If j Mod 10 = 9 Then
                Console.WriteLine((";       NextValue() = " + PC.NextValue().ToString()))
                OutputSample(PC.NextSample())
                samplesList.Add(PC.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





    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '	PERF_COUNTER_COUNTER
    '	Description	 - This counter type shows the average number of operations completed
    '		during each second of the sample interval. Counters of this type
    '		measure time in ticks of the system clock. The F variable represents
    '		the number of ticks per second. The value of F is factored into the
    '		equation so that the result can be displayed in seconds.
    '
    '	Generic type - Difference
    '
    '	Formula - (N1 - N0) / ( (D1 - D0) / F), where the numerator (N) represents the number
    '		of operations performed during the last sample interval, the denominator
    '		(D) represents the number of ticks elapsed during the last sample
    '		interval, and F is the frequency of the ticks.
    '
    '	     Average - (Nx - N0) / ((Dx - D0) / F) 
    '
    '       Example - System\ File Read Operations/sec 
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim numerator As [Single] = CType(s1.RawValue - s0.RawValue, [Single])
        Dim denomenator As [Single] = CType(s1.TimeStamp - s0.TimeStamp, [Single]) / CType(s1.SystemFrequency, [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 



RateOfCountsPerSecond64


Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class App
    Private Shared PC 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("RateOfCountsPerSecond64SampleCategory") Then


            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim rateOfCounts64 As New CounterCreationData()
            rateOfCounts64.CounterType = PerformanceCounterType.RateOfCountsPerSecond64
            rateOfCounts64.CounterName = "RateOfCountsPerSecond64Sample"
            CCDC.Add(rateOfCounts64)

            ' Create the category.
            PerformanceCounterCategory.Create("RateOfCountsPerSecond64SampleCategory", _
            "Demonstrates usage of the RateOfCountsPerSecond64 performance counter type.", _
                PerformanceCounterCategoryType.SingleInstance, CCDC)
            Return True
        Else
            Console.WriteLine("Category exists - RateOfCountsPerSecond64SampleCategory")
            Return False
        End If
    End Function 'SetupCategory


    Private Shared Sub CreateCounters()
        ' Create the counter.
        PC = New PerformanceCounter("RateOfCountsPerSecond64SampleCategory", "RateOfCountsPerSecond64Sample", False)

        PC.RawValue = 0
    End Sub 'CreateCounters


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

        Dim r As New Random(DateTime.Now.Millisecond)

        ' Initialize the performance counter.
        PC.NextSample()

        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99

            Dim value As Integer = r.Next(1, 10)
            PC.IncrementBy(value)
            Console.Write((j.ToString() + " = " + value.ToString()))

            If j Mod 10 = 9 Then
                Console.WriteLine((";       NextValue() = " + PC.NextValue().ToString()))
                OutputSample(PC.NextSample())
                samplesList.Add(PC.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




    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '	PERF_COUNTER_COUNTER
    '	Description	 - This counter type shows the average number of operations completed
    '		during each second of the sample interval. Counters of this type
    '		measure time in ticks of the system clock. The F variable represents
    '		the number of ticks per second. The value of F is factored into the
    '		equation so that the result can be displayed in seconds.
    '
    '	Generic type - Difference
    '
    '	Formula - (N1 - N0) / ( (D1 - D0) / F), where the numerator (N) represents the number
    '		of operations performed during the last sample interval, the denominator
    '		(D) represents the number of ticks elapsed during the last sample
    '		interval, and F is the frequency of the ticks.
    '
    '	Average - (Nx - N0) / ((Dx - D0) / F) 
    '
    '  Example - System\ File Read Operations/sec 
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim numerator As [Single] = CType(s1.RawValue - s0.RawValue, [Single])
        Dim denomenator As [Single] = CType(s1.TimeStamp - s0.TimeStamp, [Single]) / CType(s1.SystemFrequency, [Single])
        Dim counterValue As [Single] = numerator / denomenator
        Return counterValue
    End Function 'MyComputeCounterValue


    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



RawFraction


Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _


Public Class App
    Private Shared PC As PerformanceCounter
    Private Shared BPC 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("RawFractionSampleCategory") Then


            Dim CCDC As New CounterCreationDataCollection()

            ' Add the counter.
            Dim rf As New CounterCreationData()
            rf.CounterType = PerformanceCounterType.RawFraction
            rf.CounterName = "RawFractionSample"
            CCDC.Add(rf)

            ' Add the base counter.
            Dim rfBase As New CounterCreationData()
            rfBase.CounterType = PerformanceCounterType.RawBase
            rfBase.CounterName = "RawFractionSampleBase"
            CCDC.Add(rfBase)

            ' Create the category.
            PerformanceCounterCategory.Create("RawFractionSampleCategory", _
            "Demonstrates usage of the RawFraction performance counter type.", _
                PerformanceCounterCategoryType.SingleInstance, CCDC)

            Return True
        Else
            Console.WriteLine("Category exists - RawFractionSampleCategory")
            Return False
        End If
    End Function 'SetupCategory


    Private Shared Sub CreateCounters()
        ' Create the counters.
        PC = New PerformanceCounter("RawFractionSampleCategory", "RawFractionSample", False)

        BPC = New PerformanceCounter("RawFractionSampleCategory", "RawFractionSampleBase", False)

        PC.RawValue = 0
        BPC.RawValue = 0
    End Sub 'CreateCounters


    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

        Dim r As New Random(DateTime.Now.Millisecond)

        ' Initialize the performance counter.
        PC.NextSample()

        ' 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()))

            ' Increment the base every time, because the counter measures the number 
            ' of high hits (raw fraction value) against all the hits (base value).
            BPC.Increment()

            ' Get the % of samples that are 9 or 10 out of all the samples taken.
            If value >= 9 Then
                PC.Increment()
            End If
            ' Copy out the next value every ten times around the loop.
            If j Mod 10 = 9 Then
                Console.WriteLine((";       NextValue() = " + PC.NextValue().ToString()))
                OutputSample(PC.NextSample())
                samplesList.Add(PC.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
            ' Output the sample.
            OutputSample(CType(samplesList(i), CounterSample))

            ' Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample)).ToString())

            ' Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample)).ToString())
        Next i
    End Sub 'CalculateResults


    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    ' Formula from MSDN -
    '      Description - This counter type shows the ratio of a subset to its set as a percentage.
    '			For example, it compares the number of bytes in use on a disk to the
    '			total number of bytes on the disk. Counters of this type display the 
    '			current percentage only, not an average over time.
    '
    ' Generic type - Instantaneous, Percentage 
    '	    Formula - (N0 / D0), where D represents a measured attribute and N represents one
    '			component of that attribute.
    '
    '		Average - SUM (N / D) /x 
    '		Example - Paging File\% Usage Peak
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal rfSample As CounterSample) As [Single]
        Dim numerator As [Single] = CType(rfSample.RawValue, [Single])
        Dim denomenator As [Single] = CType(rfSample.BaseValue, [Single])
        Dim counterValue As [Single] = numerator / denomenator * 100
        Return counterValue
    End Function 'MyComputeCounterValue


    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine("+++++++++++")
        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.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft