PerformanceCounter Třída

Definice

Obor názvů:

System.Diagnostics

Sestavení:

System.Diagnostics.PerformanceCounter.dll

Zdroj:

PerformanceCounter.cs

Představuje součást čítače výkonu systému Windows NT.

public ref class PerformanceCounter sealed : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize

public sealed class PerformanceCounter : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type PerformanceCounter = class
    inherit Component
    interface ISupportInitialize

Public NotInheritable Class PerformanceCounter
Inherits Component
Implements ISupportInitialize

Dědičnost

Object

MarshalByRefObject

Component

PerformanceCounter

Implementuje

ISupportInitialize

Příklady

Následující příklad kódu ukazuje použití PerformanceCounter třídy k vytvoření a použití typu čítače AverageCount64 . Příklad vytvoří kategorie, nastaví čítače, shromažďuje data z čítačů a volá CounterSampleCalculator třídu k interpretaci dat čítače výkonu. Přechodné a konečné výsledky se zobrazí v okně konzoly. Další příklady jiných typů čítačů výkonu najdete ve výčtu PerformanceCounterType .

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class App
{
    private static PerformanceCounter avgCounter64Sample;
    private static PerformanceCounter avgCounter64SampleBase;

    public static void Main()
    {
        ArrayList samplesList = new ArrayList();

        // If the category does not exist, create the category and exit.
        // Performance counters should not be created and immediately used.
        // There is a latency time to enable the counters, they should be created
        // prior to executing the application that uses the counters.
        // Execute this sample a second time to use the category.
        if (SetupCategory())
            return;
        CreateCounters();
        CollectSamples(samplesList);
        CalculateResults(samplesList);
    }

    private static bool SetupCategory()
    {
        if ( !PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") )
        {

            CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData averageCount64 = new CounterCreationData();
            averageCount64.CounterType = PerformanceCounterType.AverageCount64;
            averageCount64.CounterName = "AverageCounter64Sample";
            counterDataCollection.Add(averageCount64);

            // Add the base counter.
            CounterCreationData averageCount64Base = new CounterCreationData();
            averageCount64Base.CounterType = PerformanceCounterType.AverageBase;
            averageCount64Base.CounterName = "AverageCounter64SampleBase";
            counterDataCollection.Add(averageCount64Base);

            // Create the category.
            PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
                "Demonstrates usage of the AverageCounter64 performance counter type.",
                PerformanceCounterCategoryType.SingleInstance, counterDataCollection);

            return(true);
        }
        else
        {
            Console.WriteLine("Category exists - AverageCounter64SampleCategory");
            return(false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counters.

        avgCounter64Sample = new PerformanceCounter("AverageCounter64SampleCategory",
            "AverageCounter64Sample",
            false);


        avgCounter64SampleBase = new PerformanceCounter("AverageCounter64SampleCategory",
            "AverageCounter64SampleBase",
            false);

        avgCounter64Sample.RawValue=0;
        avgCounter64SampleBase.RawValue=0;
    }
    private static void CollectSamples(ArrayList samplesList)
    {

        Random r = new Random( DateTime.Now.Millisecond );

        // Loop for the samples.
        for (int j = 0; j < 100; j++)
        {

            int value = r.Next(1, 10);
            Console.Write(j + " = " + value);

            avgCounter64Sample.IncrementBy(value);

            avgCounter64SampleBase.Increment();

            if ((j % 10) == 9)
            {
                OutputSample(avgCounter64Sample.NextSample());
                samplesList.Add( avgCounter64Sample.NextSample() );
            }
            else
            {
                Console.WriteLine();
            }

            System.Threading.Thread.Sleep(50);
        }
    }

    private static void CalculateResults(ArrayList samplesList)
    {
        for(int i = 0; i < (samplesList.Count - 1); i++)
        {
            // Output the sample.
            OutputSample( (CounterSample)samplesList[i] );
            OutputSample( (CounterSample)samplesList[i+1] );

            // Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " +
                CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i],
                (CounterSample)samplesList[i+1]) );

            // Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " +
                MyComputeCounterValue((CounterSample)samplesList[i],
                (CounterSample)samplesList[i+1]) );
        }
    }

    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    //    Description - This counter type shows how many items are processed, on average,
    //        during an operation. Counters of this type display a ratio of the items
    //        processed (such as bytes sent) to the number of operations completed. The
    //        ratio is calculated by comparing the number of items processed during the
    //        last interval to the number of operations completed during the last interval.
    // Generic type - Average
    //      Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number
    //        of items processed during the last sample interval and the denominator (D)
    //        represents the number of operations completed during the last two sample
    //        intervals.
    //    Average (Nx - N0) / (Dx - D0)
    //    Example PhysicalDisk\ Avg. Disk Bytes/Transfer
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
    {
        Single numerator = (Single)s1.RawValue - (Single)s0.RawValue;
        Single denomenator = (Single)s1.BaseValue - (Single)s0.BaseValue;
        Single counterValue = numerator / denomenator;
        return(counterValue);
    }

    // Output information about the counter sample.
    private static void OutputSample(CounterSample s)
    {
        Console.WriteLine("\r\n+++++++++++");
        Console.WriteLine("Sample values - \r\n");
        Console.WriteLine("   BaseValue        = " + s.BaseValue);
        Console.WriteLine("   CounterFrequency = " + s.CounterFrequency);
        Console.WriteLine("   CounterTimeStamp = " + s.CounterTimeStamp);
        Console.WriteLine("   CounterType      = " + s.CounterType);
        Console.WriteLine("   RawValue         = " + s.RawValue);
        Console.WriteLine("   SystemFrequency  = " + s.SystemFrequency);
        Console.WriteLine("   TimeStamp        = " + s.TimeStamp);
        Console.WriteLine("   TimeStamp100nSec = " + s.TimeStamp100nSec);
        Console.WriteLine("++++++++++++++++++++++");
    }
}

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

 _

Public Class App

    Private Shared avgCounter64Sample As PerformanceCounter
    Private Shared avgCounter64SampleBase As PerformanceCounter


    Public Shared Sub Main()

        Dim samplesList As New ArrayList()
        'If the category does not exist, create the category and exit.
        'Performance counters should not be created and immediately used.
        'There is a latency time to enable the counters, they should be created
        'prior to executing the application that uses the counters.
        'Execute this sample a second time to use the counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If

    End Sub

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

            Dim counterDataCollection As New CounterCreationDataCollection()

            ' Add the counter.
            Dim averageCount64 As New CounterCreationData()
            averageCount64.CounterType = PerformanceCounterType.AverageCount64
            averageCount64.CounterName = "AverageCounter64Sample"
            counterDataCollection.Add(averageCount64)

            ' Add the base counter.
            Dim averageCount64Base As New CounterCreationData()
            averageCount64Base.CounterType = PerformanceCounterType.AverageBase
            averageCount64Base.CounterName = "AverageCounter64SampleBase"
            counterDataCollection.Add(averageCount64Base)

            ' Create the category.
            PerformanceCounterCategory.Create("AverageCounter64SampleCategory", _
               "Demonstrates usage of the AverageCounter64 performance counter type.", _
                      PerformanceCounterCategoryType.SingleInstance, counterDataCollection)

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

    Private Shared Sub CreateCounters()
        ' Create the counters.

        avgCounter64Sample = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64Sample", False)

        avgCounter64SampleBase = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64SampleBase", False)

        avgCounter64Sample.RawValue = 0
        avgCounter64SampleBase.RawValue = 0
    End Sub

    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

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

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

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

            avgCounter64Sample.IncrementBy(value)

            avgCounter64SampleBase.Increment()

            If j Mod 10 = 9 Then
                OutputSample(avgCounter64Sample.NextSample())
                samplesList.Add(avgCounter64Sample.NextSample())
            Else
                Console.WriteLine()
            End If
            System.Threading.Thread.Sleep(50)
        Next j
    End Sub

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

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

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

    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '	Description - This counter type shows how many items are processed, on average,
    '		during an operation. Counters of this type display a ratio of the items 
    '		processed (such as bytes sent) to the number of operations completed. The  
    '		ratio is calculated by comparing the number of items processed during the 
    '		last interval to the number of operations completed during the last interval. 
    ' Generic type - Average
    '  	Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number 
    '		of items processed during the last sample interval and the denominator (D) 
    '		represents the number of operations completed during the last two sample 
    '		intervals. 
    '	Average (Nx - N0) / (Dx - D0)  
    '	Example PhysicalDisk\ Avg. Disk Bytes/Transfer 
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim numerator As [Single] = CType(s1.RawValue, [Single]) - CType(s0.RawValue, [Single])
        Dim denomenator As [Single] = CType(s1.BaseValue, [Single]) - CType(s0.BaseValue, [Single])
        Dim counterValue As [Single] = numerator / denomenator
        Return counterValue
    End Function 'MyComputeCounterValue

    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
        Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
        Console.WriteLine(("   BaseValue        = " + s.BaseValue.ToString()))
        Console.WriteLine(("   CounterFrequency = " + s.CounterFrequency.ToString()))
        Console.WriteLine(("   CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
        Console.WriteLine(("   CounterType      = " + s.CounterType.ToString()))
        Console.WriteLine(("   RawValue         = " + s.RawValue.ToString()))
        Console.WriteLine(("   SystemFrequency  = " + s.SystemFrequency.ToString()))
        Console.WriteLine(("   TimeStamp        = " + s.TimeStamp.ToString()))
        Console.WriteLine(("   TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
        Console.WriteLine("++++++++++++++++++++++")
    End Sub
End Class

Poznámky

Komponentu PerformanceCounter lze použít pro čtení existujících předdefinovaných nebo vlastních čítačů a publikování (zápis) dat o výkonu do vlastních čítačů.

Existuje mnoho předdefinovaných čítačů uvedených v dialogovém okně Přidat čítače monitorování výkonu systému Windows. Další informace o čítačích výkonu rozhraní .NET Framework najdete v tématu Čítače výkonu.

Tento typ implementuje rozhraní IDisposable. Jakmile skončíte s používáním typu, měli byste ho odstranit buď přímo, nebo nepřímo. Chcete-li typ odstranit přímo, zavolejte jeho Dispose metodu v bloku try/catch. Pokud ho chcete zlikvidovat nepřímo, použijte konstruktor jazyka, jako je using (v jazyce C#) nebo Using (v jazyce Visual Basic). Další informace naleznete v části Použití objektu, který implementuje IDisposable v IDisposable tématu rozhraní.

Důležité

Ve verzích 1.0 a 1.1 rozhraní .NET Framework tato třída vyžaduje okamžitou důvěryhodnost volajícího. Počínaje rozhraním .NET Framework verze 2.0 tato třída vyžaduje PerformanceCounterPermission konkrétní akce. Důrazně doporučujeme, aby PerformanceCounterPermission nebyl udělen částečně důvěryhodný kód. Schopnost číst a zapisovat čítače výkonu umožňuje kódu provádět akce, jako je výčet spuštěných procesů a získávání informací o nich.

Předání objektu méně důvěryhodnému PerformanceCounter kódu navíc může vytvořit problém se zabezpečením. Nikdy nepředávejte objekty čítače výkonu, jako je například nebo PerformanceCounterCategoryPerformanceCounter, do méně důvěryhodného kódu.

Chcete-li číst z čítače výkonu, vytvořte instanci PerformanceCounter třídy, nastavte CategoryNameCounterName, a volitelně, InstanceName nebo MachineName vlastnosti, a potom zavolejte metodu NextValue pro načtení čítače výkonu.

Pokud chcete publikovat data čítače výkonu, vytvořte pomocí metody jeden nebo více vlastních čítačůPerformanceCounterCategory.Create, vytvořte instanci PerformanceCounter třídy, nastavte CounterNameCategoryNamea volitelně InstanceName nebo MachineName vlastnosti a potom zavolejte IncrementBy, Increment, nebo Decrement metody, nebo nastavte RawValue vlastnost na změnu hodnoty vlastního čítače.

Poznámka:

Funkce Increment, IncrementBya Decrement metody používají vzájemné zámky k aktualizaci hodnoty čítače. To pomáhá udržovat hodnotu čítače přesnou ve scénářích s více vlákny nebo víceprocesy, ale také výsledkem je snížení výkonu. Pokud nepotřebujete přesnost, kterou poskytují vzájemně uzamčené operace, můžete vlastnost aktualizovat RawValue přímo o 5krát vyšší výkon. Ve scénářích s více vlákny ale můžou být některé aktualizace hodnoty čítače ignorovány, což vede k nepřesným datům.

Čítač je mechanismus, pomocí kterého se shromažďují data o výkonu. Registr ukládá názvy všech čítačů, z nichž každá souvisí s konkrétní oblastí systémových funkcí. Mezi příklady patří zaneprázdněný čas procesoru, využití paměti nebo počet bajtů přijatých přes síťové připojení.

Každý čítač je jednoznačně identifikován pomocí názvu a jeho umístění. Stejně jako cesta k souboru zahrnuje jednotku, adresář, jeden nebo více podadresářů a název souboru, informace o čítači se skládají ze čtyř prvků: počítač, kategorie, instance kategorie a název čítače.

Informace o čítači musí obsahovat kategorii nebo objekt výkonu, pro který čítač měří data. Kategorie počítače zahrnují fyzické komponenty, jako jsou procesory, disky a paměť. Existují také systémové kategorie, jako jsou procesy a vlákna. Každá kategorie souvisí s funkčním prvkem v počítači a má přiřazenou sadu standardních čítačů. Tyto objekty jsou uvedeny v rozevíracím seznamu Objekt výkonu v dialogovém okně Přidat čítače v rámci sledování systému Windows 2000 a je nutné je zahrnout do cesty čítače. Údaje o výkonu jsou seskupeny podle kategorie, ke které souvisí.

V některých případech může existovat několik kopií stejné kategorie. Například několik procesů a vláken běží současně a některé počítače obsahují více než jeden procesor. Kopie kategorií se nazývají instance kategorií a každá instance má přiřazenou sadu standardních čítačů. Pokud může mít kategorie více než jednu instanci, musí být v informacích o čítači zahrnuta specifikace instance.

Chcete-li získat údaje o výkonu pro čítače, které vyžadovaly počáteční nebo předchozí hodnotu pro provedení potřebného výpočtu, zavolejte metodu NextValue dvakrát a použijte informace vrácené podle potřeby vaší aplikace.

Poznámka:

Kategorie čítačů výkonu nainstalované s .NET používají samostatnou sdílenou paměť, přičemž každá kategorie čítače výkonu má vlastní paměť. Velikost samostatné sdílené paměti můžete určit vytvořením DWORD s názvem FileMappingSize v klíči registru HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<název> kategorie\Výkon. Hodnota FileMappingSize je nastavena na velikost sdílené paměti kategorie. Výchozí velikost je 131072 desetinných míst. Pokud hodnota FileMappingSize není k dispozici, fileMappingSize použije se hodnota atributu performanceCounters pro prvek zadaný v souboru Machine.config, což způsobuje další režii při zpracování konfiguračního souboru. Zlepšení výkonu při spuštění aplikace můžete zjistit nastavením velikosti mapování souborů v registru. Další informace o velikosti mapování souborů naleznete v tématu <performanceCounters>.

Konstruktory

Name	Description
PerformanceCounter()	Inicializuje novou instanci třídy jen pro PerformanceCounter čtení bez přidružení instance k jakémukoli systémovému nebo vlastnímu čítači výkonu.
PerformanceCounter(String, String, Boolean)	Inicializuje novou instanci PerformanceCounter třídy jen pro čtení nebo čtení/zápis a přidruží ji k zadanému systémovému nebo vlastnímu čítači výkonu v místním počítači. Tento konstruktor vyžaduje, aby kategorie obsahovala jednu instanci.
PerformanceCounter(String, String, String, Boolean)	Inicializuje novou instanci třídy jen pro čtení nebo čtení/zápis PerformanceCounter a přidruží ji k zadanému systémovému nebo vlastnímu čítači výkonu a instanci kategorie v místním počítači.
PerformanceCounter(String, String, String, String)	Inicializuje novou instanci třídy jen pro PerformanceCounter čtení a přidruží ji k zadanému systémovému nebo vlastnímu čítači výkonu a instanci kategorie v zadaném počítači.
PerformanceCounter(String, String, String)	Inicializuje novou instanci třídy jen pro PerformanceCounter čtení a přidruží ji k zadanému systémovému nebo vlastnímu čítači výkonu a instanci kategorie v místním počítači.
PerformanceCounter(String, String)	Inicializuje novou instanci PerformanceCounter třídy jen pro čtení a přidruží ji k zadanému systému nebo vlastnímu čítači výkonu v místním počítači. Tento konstruktor vyžaduje, aby kategorie měla jednu instanci.

Pole

Name	Description
DefaultFileMappingSize	Zastaralé. Určuje velikost globální paměti sdílené čítači výkonu v bajtech. Výchozí velikost je 524 288 bajtů.

Vlastnosti

Name	Description
CategoryName	Získá nebo nastaví název kategorie čítače výkonu pro tento čítač výkonu.
CounterHelp	Získá popis pro tento čítač výkonu.
CounterName	Získá nebo nastaví název čítače výkonu, který je přidružen k této PerformanceCounter instanci.
CounterType	Získá typ čítače přidruženého čítače výkonu.
InstanceLifetime	Získá nebo nastaví životnost procesu.
InstanceName	Získá nebo nastaví název instance pro tento čítač výkonu.
MachineName	Získá nebo nastaví název počítače pro tento čítač výkonu.
RawValue	Získá nebo nastaví nezpracovanou nebo nepřepočítánou hodnotu tohoto čítače.
ReadOnly	Získá nebo nastaví hodnotu určující, zda je tato PerformanceCounter instance v režimu jen pro čtení.

Metody

Name	Description
BeginInit()	Zahájí inicializaci PerformanceCounter instance použité ve formuláři nebo jinou komponentou. Inicializace probíhá za běhu.
Close()	Zavře čítač výkonu a uvolní všechny prostředky přidělené touto instancí čítače výkonu.
CloseSharedResources()	Uvolní sdílenou knihovnu čítačů výkonu přidělený čítači.
Decrement()	Sníží přidružený čítač výkonu o jeden prostřednictvím efektivní atomické operace.
EndInit()	Ukončí inicializaci PerformanceCounter instance, která se používá ve formuláři nebo jinou komponentou. Inicializace probíhá za běhu.
Increment()	Zvýší přidružený čítač výkonu o jeden prostřednictvím efektivní atomické operace.
IncrementBy(Int64)	Zvýší nebo sníží hodnotu přidruženého čítače výkonu o zadanou částku prostřednictvím efektivní atomické operace.
NextSample()	Získá vzorek čítače a vrátí nezpracovanou nebo nepřepočítánou hodnotu.
NextValue()	Získá vzorek čítače a vrátí pro něj počítanou hodnotu.
RemoveInstance()	Odstraní instanci kategorie určenou vlastností objektu PerformanceCounterInstanceName .

Viz také

• PerformanceCounterType
• CounterCreationData
• CounterCreationDataCollection
• CounterSample
• CounterSampleCalculator