PerformanceCounter Sınıf

Başvuru

Tanım

Ad Alanı:: System.Diagnostics

Bütünleştirilmiş Kod:: System.Diagnostics.PerformanceCounter.dll

Bütünleştirilmiş Kod:: System.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Windows NT performans sayacı bileşenini temsil eder.

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

Devralma: Object

MarshalByRefObject

Component
PerformanceCounter

Uygulamalar: ISupportInitialize

Örnekler

Aşağıdaki kod örneği, bir sayaç türü oluşturmak ve kullanmak AverageCount64 için sınıfının kullanımını PerformanceCounter gösterir. Örnek kategoriler oluşturur, sayaçları ayarlar, sayaçlardan veri toplar ve performans sayacı verilerini yorumlamak için sınıfını çağırır CounterSampleCalculator . Ara ve son sonuçlar konsol penceresinde görüntülenir. Diğer performans sayacı türlerine ek örnekler için numaralandırmaya PerformanceCounterType bakın.

#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

Açıklamalar

Bileşen PerformanceCounter hem mevcut önceden tanımlanmış sayaçları okumak hem de özel sayaçlarda performans verilerini yayımlamak (yazmak) için kullanılabilir.

Windows Performans İzleyicisi Sayaç Ekle iletişim kutusunda önceden tanımlanmış çok sayıda sayaç vardır. .NET Framework performans sayaçları hakkında bilgi edinmek için bkz. Performans Sayaçları.

Bu tür arabirimini IDisposable uygular. Türünü kullanmayı bitirdiğinizde, doğrudan veya dolaylı olarak atmalısınız. Türü doğrudan atmak için yöntemini bir try/catch blokta çağırın.Dispose Bunu dolaylı olarak atmak için (C#'ta) veya Using (Visual Basic'te) gibi using bir dil yapısı kullanın. Daha fazla bilgi için arabirim konusunun "IDisposable Uygulayan Bir Nesne Kullanma" bölümüne IDisposable bakın.

Önemli

.NET Framework 1.0 ve 1.1 sürümlerinde bu sınıf, anında arayanların tam olarak güvenilir olmasını gerektirir. .NET Framework sürüm 2.0'dan başlayarak, bu sınıf belirli eylemler için gereklidirPerformanceCounterPermission. Yarı güvenilir koda verilmemesi kesinlikle önerilir PerformanceCounterPermission . Performans sayaçlarını okuma ve yazma özelliği, kodun yürütme işlemlerini listeleme ve bunlar hakkında bilgi alma gibi eylemleri gerçekleştirmesine olanak tanır.

Buna ek olarak, bir PerformanceCounter nesneyi daha az güvenilen koda geçirmek bir güvenlik sorunu oluşturabilir. Veya PerformanceCountergibi PerformanceCounterCategory performans sayacı nesnelerini hiçbir zaman daha az güvenilen koda geçirmeyin.

Performans sayacından okumak için sınıfının bir örneğini PerformanceCounter oluşturun, isteğe bağlı olarak InstanceName , MachineName CounterNameve veya özelliklerini ayarlayın CategoryNameve ardından bir performans sayacı okuması almak için yöntemini çağırınNextValue.

Performans sayacı verilerini yayımlamak için yöntemini kullanarak PerformanceCounterCategory.Create bir veya daha fazla özel sayaç oluşturun, sınıfının bir örneğini PerformanceCounter oluşturun, isteğe bağlı olarak InstanceName veya MachineName özelliklerini ayarlayın CounterName CategoryName, ardından , Incrementveya yöntemlerini çağırın IncrementByya da Decrement özel sayacınızın değerini değiştirmek için özelliğini ayarlayınRawValue.

Not

Increment, IncrementByve Decrement yöntemleri, sayaç değerini güncelleştirmek için kilitleri kullanır. Bu, çok iş parçacıklı veya çok işlemli senaryolarda sayaç değerinin doğru tutulmasına yardımcı olur, ancak aynı zamanda bir performans cezasına neden olur. Birbirine kenetlenmiş işlemlerin sağladığı doğruluğa ihtiyacınız yoksa, özelliği doğrudan 5 kata kadar performans geliştirmesi için güncelleştirebilirsiniz RawValue . Ancak, çok iş parçacıklı senaryolarda, sayaç değerinde yapılan bazı güncelleştirmeler yoksayılabilir ve bu da yanlış verilere neden olabilir.

Sayaç, performans verilerinin toplandığı mekanizmadır. Kayıt defteri, her biri sistem işlevselliğinin belirli bir alanıyla ilgili olan tüm sayaçların adlarını depolar. Örnek olarak işlemcinin meşgul zamanı, bellek kullanımı veya ağ bağlantısı üzerinden alınan bayt sayısı verilebilir.

Her sayaç, adı ve konumuyla benzersiz olarak tanımlanır. Bir dosya yolunun bir sürücü, dizin, bir veya daha fazla alt dizin ve dosya adı içerdiği şekilde, sayaç bilgileri dört öğeden oluşur: bilgisayar, kategori, kategori örneği ve sayaç adı.

Sayaç bilgileri, sayacın verilerini ölçt olduğu kategoriyi veya performans nesnesini içermelidir. Bilgisayarın kategorileri işlemciler, diskler ve bellek gibi fiziksel bileşenleri içerir. İşlemler ve iş parçacıkları gibi sistem kategorileri de vardır. Her kategori, bilgisayardaki işlevsel bir öğeyle ilgilidir ve bu öğeye atanmış bir dizi standart sayaç vardır. Bu nesneler, Windows 2000 Sistem İzleyicisi içindeki Sayaç Ekle iletişim kutusunun Performans nesnesi açılan listesinde listelenir ve bunları sayaç yoluna eklemeniz gerekir. Performans verileri, ilişkili olduğu kategoriye göre gruplandırılır.

Bazı durumlarda, aynı kategorinin birkaç kopyası bulunabilir. Örneğin, birkaç işlem ve iş parçacığı aynı anda çalışır ve bazı bilgisayarlar birden fazla işlemci içerir. Kategori kopyaları kategori örnekleri olarak adlandırılır ve her örneğe atanmış bir dizi standart sayaç vardır. Bir kategoride birden fazla örnek varsa, örnek belirtimi sayaç bilgilerine eklenmelidir.

Gerekli hesaplamayı gerçekleştirmek için başlangıç veya önceki bir değer gerektiren sayaçların performans verilerini almak için yöntemini iki kez çağırın NextValue ve uygulamanızın gerektirdiği şekilde döndürülen bilgileri kullanın.

Not

.NET Framework 2.0 ile yüklenen performans sayacı kategorileri, her performans sayacı kategorisinin kendi belleğine sahip olduğu ayrı paylaşılan bellek kullanır. \Performance HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Serviceskayıt defteri anahtarında \<category name> FileMappingSize adlı bir DWORD oluşturarak ayrı paylaşılan belleğin boyutunu belirtebilirsiniz. FileMappingSize değeri, kategorinin paylaşılan bellek boyutuna ayarlanır. Varsayılan boyut ondalık 131072. FileMappingSize değeri yoksa, fileMappingSize Machine.config dosyasında belirtilen öğenin öznitelik değeri performanceCounters kullanılır ve bu da yapılandırma dosyası işleme için ek yüke neden olur. Kayıt defterinde dosya eşleme boyutunu ayarlayarak uygulama başlatma için bir performans geliştirmesi gerçekleştirebilirsiniz. Dosya eşleme boyutu hakkında daha fazla bilgi için bkz <. performanceCounters>.

Oluşturucular

PerformanceCounter()	Örneği herhangi bir sistem veya özel performans sayacıyla ilişkilendirmeden sınıfının yeni, salt okunur bir örneğini PerformanceCounter başlatır.
PerformanceCounter(String, String)	Sınıfının yeni, salt okunur bir örneğini PerformanceCounter başlatır ve bunu yerel bilgisayardaki belirtilen sistem veya özel performans sayacıyla ilişkilendirir. Bu oluşturucu, kategorinin tek bir örneğine sahip olmasını gerektirir.
PerformanceCounter(String, String, Boolean)	Sınıfının yeni, salt okunur veya okuma/yazma örneğini PerformanceCounter başlatır ve bunu yerel bilgisayardaki belirtilen sistem veya özel performans sayacıyla ilişkilendirir. Bu oluşturucu, kategorinin tek bir örnek içermesini gerektirir.
PerformanceCounter(String, String, String)	Sınıfının yeni, salt okunur bir örneğini PerformanceCounter başlatır ve bunu yerel bilgisayardaki belirtilen sistem veya özel performans sayacı ve kategori örneğiyle ilişkilendirir.
PerformanceCounter(String, String, String, Boolean)	Sınıfının yeni, salt okunur veya okuma/yazma örneğini PerformanceCounter başlatır ve bunu yerel bilgisayardaki belirtilen sistem veya özel performans sayacı ve kategori örneğiyle ilişkilendirir.
PerformanceCounter(String, String, String, String)	Sınıfının yeni, salt okunur bir örneğini PerformanceCounter başlatır ve belirtilen bilgisayardaki belirtilen sistem veya özel performans sayacı ve kategori örneğiyle ilişkilendirir.

Alanlar

DefaultFileMappingSize

Kullanımdan kalktı.

Performans sayaçları tarafından paylaşılan genel belleğin boyutunu bayt cinsinden belirtir. Varsayılan boyut 524.288 bayttır.

Özellikler

CanRaiseEvents	Bileşenin bir olay oluşturup oluşturamayacağını belirten bir değer alır. (Devralındığı yer: Component)
CategoryName	Bu performans sayacı için performans sayacı kategorisinin adını alır veya ayarlar.
Container	öğesini IContainer içeren öğesini Componentalır. (Devralındığı yer: Component)
CounterHelp	Bu performans sayacının açıklamasını alır.
CounterName	Bu PerformanceCounter örnekle ilişkili performans sayacının adını alır veya ayarlar.
CounterType	İlişkili performans sayacının sayaç türünü alır.
DesignMode	öğesinin şu anda tasarım modunda olup olmadığını Component gösteren bir değer alır. (Devralındığı yer: Component)
Events	Bu Componentöğesine eklenen olay işleyicilerinin listesini alır. (Devralındığı yer: Component)
InstanceLifetime	Bir işlemin ömrünü alır veya ayarlar.
InstanceName	Bu performans sayacı için bir örnek adı alır veya ayarlar.
MachineName	Bu performans sayacı için bilgisayar adını alır veya ayarlar.
RawValue	Bu sayacın ham veya hesaplanmamış değerini alır veya ayarlar.
ReadOnly	Bu PerformanceCounter örneğin salt okunur modda olup olmadığını belirten bir değer alır veya ayarlar.
Site	öğesini alır veya ayarlar ISite Component. (Devralındığı yer: Component)

Yöntemler

BeginInit()	Formda veya başka bir PerformanceCounter bileşen tarafından kullanılan bir örneğin başlatılmasını başlatır. Başlatma çalışma zamanında gerçekleşir.
Close()	Performans sayacını kapatır ve bu performans sayacı örneği tarafından ayrılan tüm kaynakları serbesttir.
CloseSharedResources()	Sayaçlar tarafından ayrılan performans sayacı kitaplığı paylaşılan durumunu serbesttir.
CreateObjRef(Type)	Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm ilgili bilgileri içeren bir nesne oluşturur. (Devralındığı yer: MarshalByRefObject)
Decrement()	Verimli bir atomik işlem aracılığıyla ilişkili performans sayacını bir azaltma.
Dispose()	Component tarafından kullanılan tüm kaynakları serbest bırakır. (Devralındığı yer: Component)
Dispose(Boolean)	Component tarafından kullanılan yönetilmeyen kaynakları serbest bırakır ve yönetilen kaynakları isteğe bağlı olarak serbest bırakır. (Devralındığı yer: Component)
EndInit()	Bir formda veya başka bir PerformanceCounter bileşen tarafından kullanılan bir örneğin başlatılmasını sonlandırır. Başlatma çalışma zamanında gerçekleşir.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetLifetimeService()	Kullanımdan kalktı. Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır. (Devralındığı yer: MarshalByRefObject)
GetService(Type)	veya tarafından Component Containersağlanan bir hizmeti temsil eden bir nesnesi döndürür. (Devralındığı yer: Component)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
Increment()	Verimli bir atomik işlem aracılığıyla ilişkili performans sayacını bir artırır.
IncrementBy(Int64)	Verimli bir atomik işlem aracılığıyla ilişkili performans sayacının değerini belirtilen miktarda artırır veya düşürür.
InitializeLifetimeService()	Kullanımdan kalktı. Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır. (Devralındığı yer: MarshalByRefObject)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnenin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
NextSample()	Bir sayaç örneği alır ve bunun ham veya hesaplanmamış değerini döndürür.
NextValue()	Bir sayaç örneği alır ve bunun hesaplanan değerini döndürür.
RemoveInstance()	object InstanceName özelliği tarafından belirtilen kategori örneğini PerformanceCounter siler.
ToString()	Varsa, adını Componentiçeren bir String döndürür. Bu yöntem geçersiz kılınmamalıdır. (Devralındığı yer: Component)

Ekinlikler

Disposed

Bileşen yöntemine Dispose() yapılan bir çağrı tarafından atıldığında gerçekleşir.

(Devralındığı yer: Component)

Şunlara uygulanır