PerformanceCounter Klasa

Definicja

Reprezentuje składnik licznika wydajności systemu Windows NT.Represents a Windows NT performance counter component.

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

Przykłady

Poniższy przykład kodu demonstruje użycie PerformanceCounter klasy do tworzenia i używania AverageCount64 typu licznika.The following code example demonstrates the use of the PerformanceCounter class to create and use an AverageCount64 counter type. Przykład tworzy kategorie, konfiguruje liczniki, zbiera dane z liczników i wywołuje CounterSampleCalculator klasę, aby interpretować dane licznika wydajności.The example creates categories, sets up counters, collects data from the counters, and calls the CounterSampleCalculator class to interpret the performance counter data. Wyniki pośrednie i końcowe są wyświetlane w oknie konsoli.The intermediate and final results are displayed in the console window. Dodatkowe przykłady dotyczące innych typów liczników wydajności można znaleźć w PerformanceCounterType wyliczeniu.For additional examples of other performance counter types, see the PerformanceCounterType enumeration.

#using <System.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
using namespace System::Diagnostics;

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

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

bool SetupCategory()
{
   if (  !PerformanceCounterCategory::Exists( "AverageCounter64SampleCategory" ) )
   {
      CounterCreationDataCollection^ CCDC = gcnew CounterCreationDataCollection;
      
      // Add the counter.
      CounterCreationData^ averageCount64 = gcnew CounterCreationData;
      averageCount64->CounterType = PerformanceCounterType::AverageCount64;
      averageCount64->CounterName = "AverageCounter64Sample";
      CCDC->Add( averageCount64 );
      
      // Add the base counter.
      CounterCreationData^ averageCount64Base = gcnew CounterCreationData;
      averageCount64Base->CounterType = PerformanceCounterType::AverageBase;
      averageCount64Base->CounterName = "AverageCounter64SampleBase";
      CCDC->Add( averageCount64Base );
      
      // Create the category.
      PerformanceCounterCategory::Create( "AverageCounter64SampleCategory", "Demonstrates usage of the AverageCounter64 performance counter type.", CCDC );
      return (true);
   }
   else
   {
      Console::WriteLine( "Category exists - AverageCounter64SampleCategory" );
      return (false);
   }
}

void CreateCounters( PerformanceCounter^% PC, PerformanceCounter^% BPC )
{
   
   // Create the counters.
   PC = gcnew PerformanceCounter( "AverageCounter64SampleCategory","AverageCounter64Sample",false );

   BPC = gcnew PerformanceCounter( "AverageCounter64SampleCategory","AverageCounter64SampleBase",false );
   PC->RawValue = 0;
   BPC->RawValue = 0;
}
void CollectSamples( ArrayList^ samplesList, PerformanceCounter^ PC, PerformanceCounter^ BPC )
{
   Random^ r = gcnew Random( DateTime::Now.Millisecond );

   // Loop for the samples.
   for ( int j = 0; j < 100; j++ )
   {
      int value = r->Next( 1, 10 );
      Console::Write( "{0} = {1}", j, value );
      PC->IncrementBy( value );
      BPC->Increment();
      if ( (j % 10) == 9 )
      {
         OutputSample( PC->NextSample() );
         samplesList->Add( PC->NextSample() );
      }
      else
            Console::WriteLine();
      System::Threading::Thread::Sleep( 50 );
   }
}

void CalculateResults( ArrayList^ samplesList )
{
   for ( int i = 0; i < (samplesList->Count - 1); i++ )
   {
      // Output the sample.
      OutputSample(  *safe_cast<CounterSample^>(samplesList[ i ]) );
      OutputSample(  *safe_cast<CounterSample^>(samplesList[ i + 1 ]) );
      
      // Use .NET to calculate the counter value.
      Console::WriteLine( ".NET computed counter value = {0}", CounterSampleCalculator::ComputeCounterValue(  *safe_cast<CounterSample^>(samplesList[ i ]),  *safe_cast<CounterSample^>(samplesList[ i + 1 ]) ) );
      
      // Calculate the counter value manually.
      Console::WriteLine( "My computed counter value = {0}", MyComputeCounterValue(  *safe_cast<CounterSample^>(samplesList[ i ]),  *safe_cast<CounterSample^>(samplesList[ i + 1 ]) ) );
   }
}

int main()
{
   ArrayList^ samplesList = gcnew ArrayList;
   PerformanceCounter^ PC;
   PerformanceCounter^ BPC;
   SetupCategory();
   CreateCounters( PC, BPC );
   CollectSamples( samplesList, PC, BPC );
   CalculateResults( samplesList );
}

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

public class App {

    private static PerformanceCounter avgCounter64Sample;
    private static PerformanceCounter avgCounter64SampleBase;

    public static void Main()
    {

        ArrayList samplesList = new ArrayList();

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

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

            CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();

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

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

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

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

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

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


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

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

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

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

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

            avgCounter64Sample.IncrementBy(value);

            avgCounter64SampleBase.Increment();

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

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

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

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

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

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

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

 _

Public Class App

    Private Shared avgCounter64Sample As PerformanceCounter
    Private Shared avgCounter64SampleBase As PerformanceCounter


    Public Shared Sub Main()

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

    End Sub

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

            Dim counterDataCollection As New CounterCreationDataCollection()

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

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

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

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

    Private Shared Sub CreateCounters()
        ' Create the counters.

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

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

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

    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

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

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

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

            avgCounter64Sample.IncrementBy(value)

            avgCounter64SampleBase.Increment()

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

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

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

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

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

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

Uwagi

PerformanceCounterSkładnik ten może służyć do odczytywania istniejących wstępnie zdefiniowanych lub niestandardowych liczników oraz publikowania (zapisywania) danych wydajności do liczników niestandardowych.The PerformanceCounter component can be used for both reading existing predefined or custom counters and publishing (writing) performance data to custom counters.

W oknie dialogowym Dodawanie licznikówmonitora wydajności systemu Windows jest dostępnych wiele wstępnie zdefiniowanych liczników.There are numerous predefined counters listed in the Windows Performance Monitor's Add Counters dialog box. Aby dowiedzieć się więcej o licznikach wydajności .NET Framework, zobacz liczniki wydajności.To learn about the .NET Framework performance counters, see Performance Counters.

Ten typ implementuje IDisposable interfejs.This type implements the IDisposable interface. Po zakończeniu korzystania z typu należy usunąć jego wartość bezpośrednio lub pośrednio.When you have finished using the type, you should dispose of it either directly or indirectly. Aby usunąć typ bezpośrednio, wywołaj jego Dispose metodę w try / catch bloku.To dispose of the type directly, call its Dispose method in a try/catch block. Aby usunąć go pośrednio, użyj konstrukcji języka, takiej jak using (w języku C#) lub Using (w Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Aby uzyskać więcej informacji, zobacz sekcję "Używanie obiektu implementującego interfejs IDisposable" w temacie dotyczącym IDisposable interfejsu.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Ważne

W wersjach 1,0 i 1,1 .NET Framework Ta klasa wymaga, aby natychmiastowe wywołania były w pełni zaufane.In versions 1.0 and 1.1 of the .NET Framework, this class requires immediate callers to be fully trusted. Począwszy od .NET Framework w wersji 2,0, ta klasa jest wymagana PerformanceCounterPermission dla określonych akcji.Starting with the .NET Framework version 2.0, this class requires PerformanceCounterPermission for specific actions. Zdecydowanie zaleca się, aby PerformanceCounterPermission nie przydzielić mu kodu częściowo zaufanego.It is strongly recommended that PerformanceCounterPermission not be granted to semi-trusted code. Możliwość odczytu i zapisu liczników wydajności umożliwia kod do wykonywania akcji, takich jak Wyliczenie procesów wykonywania i uzyskiwanie informacji o nich.The ability to read and write performance counters allows code to perform actions such as enumerating executing processes and obtaining information about them.

Ponadto przekazywanie PerformanceCounter obiektu do bardziej zaufanego kodu może spowodować problem z zabezpieczeniami.In addition, passing a PerformanceCounter object to less-trusted code can create a security issue. Nigdy nie przekazuj obiektów liczników wydajności, takich jak PerformanceCounterCategory lub PerformanceCounter , do mniej zaufanych kodów.Never pass performance counter objects, such as a PerformanceCounterCategory or PerformanceCounter, to less trusted code.

Aby odczytać z licznika wydajności, Utwórz wystąpienie PerformanceCounter klasy, ustaw parametry CategoryName , CounterName , i, opcjonalnie, InstanceName MachineName właściwości lub, a następnie Wywołaj NextValue metodę, aby wykonać odczyt licznika wydajności.To read from a performance counter, create an instance of the PerformanceCounter class, set the CategoryName, CounterName, and, optionally, the InstanceName or MachineName properties, and then call the NextValue method to take a performance counter reading.

Aby opublikować dane licznika wydajności, należy utworzyć co najmniej jeden niestandardowy licznik przy użyciu PerformanceCounterCategory.Create metody, utworzyć wystąpienie PerformanceCounter klasy, ustawić CategoryName , CounterName i opcjonalnie InstanceName lub MachineName właściwości, a następnie wywołać IncrementBy metody, Increment , lub Decrement ustawić RawValue Właściwość w celu zmiany wartości licznika niestandardowego.To publish performance counter data, create one or more custom counters using the PerformanceCounterCategory.Create method, create an instance of the PerformanceCounter class, set the CategoryName, CounterName and, optionally, InstanceName or MachineName properties, and then call the IncrementBy, Increment, or Decrement methods, or set the RawValue property to change the value of your custom counter.

Uwaga

IncrementMetody, IncrementBy i Decrement służą do aktualizowania wartości licznika.The Increment, IncrementBy, and Decrement methods use interlocks to update the counter value. Dzięki temu wartość licznika jest poprawna w scenariuszach wielowątkowych lub wielowątkowych, ale również powstaje spadek wydajności.This helps keep the counter value accurate in multithreaded or multiprocess scenarios, but also results in a performance penalty. Jeśli nie potrzebujesz dokładności zapewnianej przez operacje wykonywane w sposób niezbędny, możesz zaktualizować RawValue Właściwość bezpośrednio przez maksymalnie 5 razy zwiększenie wydajności.If you do not need the accuracy that interlocked operations provide, you can update the RawValue property directly for up to a 5 times performance improvement. Jednak w scenariuszach wielowątkowych niektóre aktualizacje wartości licznika mogą zostać zignorowane, co spowodowało niedokładne dane.However, in multithreaded scenarios, some updates to the counter value might be ignored, resulting in inaccurate data.

Licznik jest mechanizmem, za pomocą którego zbierane są dane wydajności.The counter is the mechanism by which performance data is collected. W rejestrze są przechowywane nazwy wszystkich liczników, z których każdy jest powiązany z określonym obszarem funkcji systemu.The registry stores the names of all the counters, each of which is related to a specific area of system functionality. Przykłady obejmują czas zajętości procesora, użycie pamięci lub liczbę bajtów odebranych za pośrednictwem połączenia sieciowego.Examples include a processor's busy time, memory usage, or the number of bytes received over a network connection.

Każdy licznik jest jednoznacznie identyfikowany za jego nazwą i lokalizacją.Each counter is uniquely identified through its name and its location. W taki sam sposób, w jaki ścieżka pliku zawiera dysk, katalog, jeden lub więcej podkatalogów i nazwę pliku, informacje o licznikach składają się z czterech elementów: komputera, kategorii, wystąpienia kategorii i nazwy licznika.In the same way that a file path includes a drive, a directory, one or more subdirectories, and a file name, counter information consists of four elements: the computer, the category, the category instance, and the counter name.

Informacje o licznikach muszą obejmować kategorię lub obiekt wydajności, z których Licznik mierzy dane.The counter information must include the category, or performance object, that the counter measures data for. Kategorie komputerów obejmują składniki fizyczne, takie jak procesory, dyski i pamięć.A computer's categories include physical components, such as processors, disks, and memory. Istnieją także kategorie systemowe, takie jak procesy i wątki.There are also system categories, such as processes and threads. Każda kategoria jest powiązana z elementem funkcjonalnym w ramach komputera i ma zestaw przypisanych do niego standardowych liczników.Each category is related to a functional element within the computer and has a set of standard counters assigned to it. Te obiekty są wymienione na liście rozwijanej obiekt wydajności okna dialogowego Dodawanie liczników w ramach monitora systemu Windows 2000 i należy je uwzględnić w ścieżce licznika.These objects are listed in the Performance object drop-down list of the Add Counters dialog box within the Windows 2000 System Monitor, and you must include them in the counter path. Dane wydajności są pogrupowane według kategorii, z którą jest powiązana.Performance data is grouped by the category to which is it related.

W niektórych przypadkach może istnieć kilka kopii tej samej kategorii.In certain cases, several copies of the same category can exist. Na przykład kilka procesów i wątków działa jednocześnie, a niektóre komputery zawierają więcej niż jeden procesor.For example, several processes and threads run simultaneously, and some computers contain more than one processor. Kopie kategorii są nazywane wystąpieniami kategorii, a każde wystąpienie ma przypisany zestaw standardowych liczników.The category copies are called category instances, and each instance has a set of standard counters assigned to it. Jeśli kategoria może mieć więcej niż jedno wystąpienie, Specyfikacja wystąpienia musi być uwzględniona w informacjach o liczniku.If a category can have more than one instance, an instance specification must be included in the counter information.

Aby uzyskać dane dotyczące wydajności dla liczników, które wymagały początkowej lub poprzedniej wartości do wykonania niezbędnych obliczeń, wywołaj NextValue metodę dwukrotnie i Użyj informacji zwracanych w zależności od potrzeb aplikacji.To obtain performance data for counters that required an initial or previous value for performing the necessary calculation, call the NextValue method twice and use the information returned as your application requires.

Uwaga

Kategorie licznika wydajności zainstalowane z .NET Framework 2,0 używają oddzielnej pamięci współdzielonej, z każdą kategorią licznika wydajności mającą własną pamięć.Performance counter categories installed with the .NET Framework 2.0 use separate shared memory, with each performance counter category having its own memory. Można określić rozmiar oddzielnej pamięci współdzielonej przez utworzenie typu DWORD o nazwie FileMappingSize w kluczu rejestru HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ <category name> \Performance.You can specify the size of separate shared memory by creating a DWORD named FileMappingSize in the registry key HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<category name> \Performance. Wartość FileMappingSize jest ustawiona na rozmiar pamięci współdzielonej kategorii.The FileMappingSize value is set to the shared memory size of the category. Domyślny rozmiar to 131072 dziesiętny.The default size is 131072 decimal. Jeśli wartość FileMappingSize nie jest obecna, zostanie fileMappingSize użyta wartość atrybutu dla performanceCounters elementu określonego w pliku Machine.config, co spowoduje dodatkowe obciążenie związane z przetwarzaniem plików konfiguracyjnych.If the FileMappingSize value is not present, the fileMappingSize attribute value for the performanceCounters element specified in the Machine.config file is used, causing additional overhead for configuration file processing. Zwiększenie wydajności uruchamiania aplikacji można zrealizować przez ustawienie rozmiaru mapowania plików w rejestrze.You can realize a performance improvement for application startup by setting the file mapping size in the registry. Aby uzyskać więcej informacji o rozmiarze mapowania plików, zobacz < liczniki wydajności > .For more information about the file mapping size, see <performanceCounters>.

Konstruktory

PerformanceCounter()

Inicjuje nowe wystąpienie tylko do odczytu PerformanceCounter klasy, bez kojarzenia wystąpienia z dowolnym system lub niestandardowy licznik wydajności.Initializes a new, read-only instance of the PerformanceCounter class, without associating the instance with any system or custom performance counter.

PerformanceCounter(String, String)

Inicjuje nowe wystąpienie tylko do odczytu PerformanceCounter klasy i kojarzy je z określonym systemem lub niestandardowym licznikiem wydajności na komputerze lokalnym.Initializes a new, read-only instance of the PerformanceCounter class and associates it with the specified system or custom performance counter on the local computer. Ten Konstruktor wymaga, aby Kategoria miała pojedyncze wystąpienie.This constructor requires that the category have a single instance.

PerformanceCounter(String, String, Boolean)

Inicjuje nowe wystąpienie, tylko do odczytu lub odczytu/zapisu PerformanceCounter klasy i kojarzy je z określonym systemem lub niestandardowym licznikiem wydajności na komputerze lokalnym.Initializes a new, read-only or read/write instance of the PerformanceCounter class and associates it with the specified system or custom performance counter on the local computer. Ten Konstruktor wymaga, aby Kategoria zawierała pojedyncze wystąpienie.This constructor requires that the category contain a single instance.

PerformanceCounter(String, String, String)

Inicjuje nowe wystąpienie tylko do odczytu PerformanceCounter klasy i kojarzy je z określonym systemem lub niestandardowym licznikiem wydajności i wystąpieniem kategorii na komputerze lokalnym.Initializes a new, read-only instance of the PerformanceCounter class and associates it with the specified system or custom performance counter and category instance on the local computer.

PerformanceCounter(String, String, String, Boolean)

Inicjuje nowe wystąpienie, tylko do odczytu lub odczytu/zapisu PerformanceCounter klasy i kojarzy je z określonym systemem lub niestandardowym licznikiem wydajności i wystąpieniem kategorii na komputerze lokalnym.Initializes a new, read-only or read/write instance of the PerformanceCounter class and associates it with the specified system or custom performance counter and category instance on the local computer.

PerformanceCounter(String, String, String, String)

Inicjuje nowe wystąpienie tylko do odczytu PerformanceCounter klasy i kojarzy je z określonym systemem lub niestandardowym licznikiem wydajności i wystąpieniem kategorii na określonym komputerze.Initializes a new, read-only instance of the PerformanceCounter class and associates it with the specified system or custom performance counter and category instance, on the specified computer.

Pola

DefaultFileMappingSize
Nieaktualne.
Nieaktualne.

Określa rozmiar pamięci globalnej udostępnionej przez liczniki wydajności w bajtach.Specifies the size, in bytes, of the global memory shared by performance counters. Domyślny rozmiar to 524 288 bajtów.The default size is 524,288 bytes.

Właściwości

CanRaiseEvents

Pobiera wartość wskazującą, czy składnik może zgłosić zdarzenie.Gets a value indicating whether the component can raise an event.

(Odziedziczone po Component)
CategoryName

Pobiera lub ustawia nazwę kategorii licznika wydajności dla tego licznika wydajności.Gets or sets the name of the performance counter category for this performance counter.

Container

Pobiera IContainer , który zawiera Component .Gets the IContainer that contains the Component.

(Odziedziczone po Component)
CounterHelp

Pobiera opis tego licznika wydajności.Gets the description for this performance counter.

CounterName

Pobiera lub ustawia nazwę licznika wydajności, który jest skojarzony z tym PerformanceCounter wystąpieniem.Gets or sets the name of the performance counter that is associated with this PerformanceCounter instance.

CounterType

Pobiera typ licznika skojarzonego licznika wydajności.Gets the counter type of the associated performance counter.

DesignMode

Pobiera wartość wskazującą, czy Component jest aktualnie w trybie projektowania.Gets a value that indicates whether the Component is currently in design mode.

(Odziedziczone po Component)
Events

Pobiera listę programów obsługi zdarzeń, które są dołączone do tego elementu Component .Gets the list of event handlers that are attached to this Component.

(Odziedziczone po Component)
InstanceLifetime

Pobiera lub ustawia okres istnienia procesu.Gets or sets the lifetime of a process.

InstanceName

Pobiera lub ustawia nazwę wystąpienia dla tego licznika wydajności.Gets or sets an instance name for this performance counter.

MachineName

Pobiera lub ustawia nazwę komputera dla tego licznika wydajności.Gets or sets the computer name for this performance counter.

RawValue

Pobiera lub ustawia wartość nieprzetworzoną lub nieobliczoną dla tego licznika.Gets or sets the raw, or uncalculated, value of this counter.

ReadOnly

Pobiera lub ustawia wartość wskazującą, czy to PerformanceCounter wystąpienie jest w trybie tylko do odczytu.Gets or sets a value indicating whether this PerformanceCounter instance is in read-only mode.

Site

Pobiera lub ustawia wartość ISite Component .Gets or sets the ISite of the Component.

(Odziedziczone po Component)

Metody

BeginInit()

Rozpoczyna inicjowanie PerformanceCounter wystąpienia używanego w formularzu lub przez inny składnik.Begins the initialization of a PerformanceCounter instance used on a form or by another component. Inicjalizacja odbywa się w czasie wykonywania.The initialization occurs at runtime.

Close()

Zamyka licznik wydajności i zwalnia wszystkie zasoby przydzielone przez to wystąpienie licznika wydajności.Closes the performance counter and frees all the resources allocated by this performance counter instance.

CloseSharedResources()

Zwalnia współużytkowany stan biblioteki licznika wydajności przydzielonej przez liczniki.Frees the performance counter library shared state allocated by the counters.

CreateObjRef(Type)

Tworzy obiekt, który zawiera wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikacji z obiektem zdalnym.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Odziedziczone po MarshalByRefObject)
Decrement()

Zmniejsza skojarzony licznik wydajności o jeden przez wydajną operację niepodzielną.Decrements the associated performance counter by one through an efficient atomic operation.

Dispose()

Zwalnia wszelkie zasoby używane przez element Component.Releases all resources used by the Component.

(Odziedziczone po Component)
Dispose(Boolean)

Zwalnia zasoby niezarządzane używane przez element Component i opcjonalnie zwalnia zasoby zarządzane.Releases the unmanaged resources used by the Component and optionally releases the managed resources.

(Odziedziczone po Component)
EndInit()

Zamyka inicjowanie PerformanceCounter wystąpienia, które jest używane w formularzu lub przez inny składnik.Ends the initialization of a PerformanceCounter instance that is used on a form or by another component. Inicjalizacja odbywa się w czasie wykonywania.The initialization occurs at runtime.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetLifetimeService()
Nieaktualne.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
GetService(Type)

Zwraca obiekt, który reprezentuje usługę dostarczoną przez Component lub przez Container .Returns an object that represents a service provided by the Component or by its Container.

(Odziedziczone po Component)
GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
Increment()

Zwiększa skojarzony licznik wydajności o jeden przez wydajną operację niepodzielną.Increments the associated performance counter by one through an efficient atomic operation.

IncrementBy(Int64)

Zwiększa lub zmniejsza wartość skojarzonego licznika wydajności o określoną wartość za pomocą wydajnej operacji niepodzielnej.Increments or decrements the value of the associated performance counter by a specified amount through an efficient atomic operation.

InitializeLifetimeService()
Nieaktualne.

Uzyskuje obiekt usługi istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy skróconą kopię bieżącego MarshalByRefObject obiektu.Creates a shallow copy of the current MarshalByRefObject object.

(Odziedziczone po MarshalByRefObject)
NextSample()

Uzyskuje przykład licznika i zwraca nieprzetworzoną lub nieobliczoną wartość.Obtains a counter sample, and returns the raw, or uncalculated, value for it.

NextValue()

Uzyskuje próbkę licznika i zwraca obliczoną wartość dla niej.Obtains a counter sample and returns the calculated value for it.

RemoveInstance()

Usuwa wystąpienie kategorii określone przez PerformanceCounter InstanceName Właściwość Object.Deletes the category instance specified by the PerformanceCounter object InstanceName property.

ToString()

Zwraca wartość String zawierającą nazwę Component (jeśli istnieje).Returns a String containing the name of the Component, if any. Ta metoda nie powinna być przesłaniana.This method should not be overridden.

(Odziedziczone po Component)

Zdarzenia

Disposed

Występuje, gdy składnik zostanie usunięty przez wywołanie Dispose() metody.Occurs when the component is disposed by a call to the Dispose() method.

(Odziedziczone po Component)

Dotyczy

Zobacz też