PerformanceCounter PerformanceCounter PerformanceCounter PerformanceCounter Class

정의

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
상속
구현

예제

다음 코드 예제에서는 합니다 PerformanceCounter 만들고 사용 하는 클래스는 AverageCount64 카운터 형식과 합니다.The following code example demonstrates the use of the PerformanceCounter class to create and use an AverageCount64 counter type. 예제 범주, 카운터를 설정, 카운터 및 호출에서 데이터를 수집 합니다 CounterSampleCalculator 성능 카운터 데이터를 해석 하는 클래스입니다.The example creates categories, sets up counters, collects data from the counters, and calls the CounterSampleCalculator class to interpret the performance counter data. 중간 및 최종 결과 콘솔 창에 표시 됩니다.The intermediate and final results are displayed in the console window. 다른 성능 카운터 형식의 추가 예 참조는 PerformanceCounterType 열거형입니다.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
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class App

    Private Shared avgCounter64Sample As PerformanceCounter
    Private Shared avgCounter64SampleBase As PerformanceCounter


    Public Shared Sub Main()

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

    End Sub 'Main

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

            Dim counterDataCollection As New CounterCreationDataCollection()

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

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

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

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

    Private Shared Sub CreateCounters()
        ' Create the counters.

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

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

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

    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

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

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

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

            avgCounter64Sample.IncrementBy(value)

            avgCounter64SampleBase.Increment()

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

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

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

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

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

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

설명

PerformanceCounter 미리 정의 된 기존 또는 사용자 지정 카운터 읽기와 게시 (쓰기) 성능에 대 한 구성 요소를 사용할 수 데이터를 사용자 지정 카운터입니다.The PerformanceCounter component can be used for both reading existing predefined or custom counters and publishing (writing) performance data to custom counters.

Windows 성능 모니터에 나열 된 다양 한 미리 정의 된 카운터가 카운터 추가 대화 상자합니다.There are numerous predefined counters listed in the Windows Performance Monitor's Add Counters dialog box. .NET Framework 성능 카운터를 알아보려면 성능 카운터합니다.To learn about the .NET Framework performance counters, see Performance Counters.

이 형식이 구현 하는 IDisposable 인터페이스입니다.This type implements the IDisposable interface. 형식을 사용 하 여 마쳤으면 직접 또는 간접적으로의 삭제 해야 있습니다.When you have finished using the type, you should dispose of it either directly or indirectly. 직접 형식의 dispose 호출 해당 Dispose 의 메서드를 try / catch 블록입니다.To dispose of the type directly, call its Dispose method in a try/catch block. 삭제 하지 직접, 언어 구문 같은 사용 using (C#에서) 또는 Using (Visual Basic에서는).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). 자세한 내용은 "를 사용 하는 개체는 구현 IDisposable" 섹션을 참조 하세요.를 IDisposable 인터페이스 항목입니다.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

중요

버전 1.0 및 1.1의.NET Framework에서는이 클래스는 완전히 신뢰 된 코드로 직접 실행 호출자가 필요 합니다.In versions 1.0 and 1.1 of the .NET Framework, this class requires immediate callers to be fully trusted. 이 클래스에 필요한.NET Framework 버전 2.0부터 PerformanceCounterPermission 특정 작업에 대 한 합니다.Starting with the .NET Framework version 2.0, this class requires PerformanceCounterPermission for specific actions. 것이 좋습니다는 PerformanceCounterPermission 부분 신뢰 코드에 부여 되지 않습니다.It is strongly recommended that PerformanceCounterPermission not be granted to semi-trusted code. 읽기 및 쓰기 성능 카운터 수에는 코드를를 실행 중인 프로세스 및 가져오는 데 정보를 열거 하는 등 작업을 수행할 수 있습니다.The ability to read and write performance counters allows code to perform actions such as enumerating executing processes and obtaining information about them.

또한 전달 된 PerformanceCounter 개체 신뢰할 수 없는 코드를 보안 문제가 발생할 수 있습니다.In addition, passing a PerformanceCounter object to less-trusted code can create a security issue. 전달 하지 성능 카운터 개체와 같은 PerformanceCounterCategory 또는 PerformanceCounter를 신뢰할 수 있는 작은 코드입니다.Never pass performance counter objects, such as a PerformanceCounterCategory or PerformanceCounter, to less trusted code.

성능 카운터를 읽어올 수의 인스턴스를 만듭니다는 PerformanceCounter 클래스에서 합니다 CategoryName, CounterName, 및 필요에 따라를 InstanceName 또는 MachineName 속성 및 호출은 NextValue 성능 수행 하는 방법 카운터를 읽습니다.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.

성능 카운터 데이터를 게시 하려면 사용 하 여 하나 이상의 사용자 지정 카운터를 만듭니다는 PerformanceCounterCategory.Create 메서드를의 인스턴스를 만듭니다를 PerformanceCounter 클래스에서 합니다 CategoryName, CounterName 및 필요에 따라 InstanceName 또는 MachineName 속성 호출을 IncrementBy, Increment, 또는 Decrement 메서드 또는 집합을 RawValue 속성을 사용자 지정 카운터의 값을 변경 합니다.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.

참고

합니다 Increment, IncrementBy, 및 Decrement 메서드 상호 잠금을 사용 하 여 카운터 값을 업데이트 합니다.The Increment, IncrementBy, and Decrement methods use interlocks to update the counter value. 이렇게 하면 다중 스레드 또는 다중 프로세스 시나리오 뿐만 아니라 성능 저하에서는 결과의 카운터 값을 정확 하 게 유지 합니다.This helps keep the counter value accurate in multithreaded or multiprocess scenarios, but also results in a performance penalty. 연동 하는 정확도 필요 하지 않은 경우 작업을 제공, 업데이트할 수 있습니다는 RawValue 5까지 속성에 직접 시간 성능 향상.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. 그러나 다중 스레드 시나리오에서 몇 가지 업데이트 카운터 값을 무시 될 수 있습니다, 잘못 된 데이터가 생성 합니다.However, in multithreaded scenarios, some updates to the counter value might be ignored, resulting in inaccurate data.

카운터는 성능에서 데이터가 수집 되는 메커니즘입니다.The counter is the mechanism by which performance data is collected. 레지스트리는 시스템 기능의 특정 영역 관련이 있으며 각 모든 카운터의 이름을 저장 합니다.The registry stores the names of all the counters, each of which is related to a specific area of system functionality. 프로세서의 사용량이 많은 시간, 메모리 사용량 또는 네트워크 연결을 통해 수신 된 바이트 수가 예로 들 수 있습니다.Examples include a processor's busy time, memory usage, or the number of bytes received over a network connection.

각 카운터의 이름 및 해당 위치를 통해 고유 하 게 식별 됩니다.Each counter is uniquely identified through its name and its location. 파일 경로 드라이브, 디렉터리, 하나 이상의 하위 디렉터리 및 파일 이름을 포함 하는 동일한 방법으로 네 가지 요소로 구성 됩니다 카운터 정보: 컴퓨터, 범주, 범주 인스턴스 및 카운터 이름입니다.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.

범주 또는 성능 개체, 카운터에 대 한 데이터를 측정 하는 카운터 정보를 포함 해야 합니다.The counter information must include the category, or performance object, that the counter measures data for. 프로세서, 디스크 및 메모리와 같은 물리적 구성 요소를 포함 하는 컴퓨터의 범주입니다.A computer's categories include physical components, such as processors, disks, and memory. 프로세스 및 스레드와 같은 시스템 범주도 있습니다.There are also system categories, such as processes and threads. 각 범주의 컴퓨터에서 기능 요소와 관련 되며 및 표준 카운터 집합을 할당 합니다.Each category is related to a functional element within the computer and has a set of standard counters assigned to it. 이러한 개체는 Windows 2000 시스템 모니터 내에서 카운터 추가 대화 상자의 성능 개체 드롭다운 목록에서 나열 하 고 카운터 경로에 포함 해야 합니다.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. 성능 데이터를 범주는 관련 하 여 그룹화 됩니다.Performance data is grouped by the category to which is it related.

경우에 따라 동일한 범주의 여러 복사본이 있을 수 있습니다.In certain cases, several copies of the same category can exist. 예를 들어, 여러 프로세스 및 스레드 동시에 실행 하 고 일부 컴퓨터는 둘 이상의 프로세서를 포함 합니다.For example, several processes and threads run simultaneously, and some computers contain more than one processor. 범주 복사본은 범주 인스턴스를 호출 하 고 각 인스턴스에 할당 된 표준 카운터 집합이 키를 누릅니다.The category copies are called category instances, and each instance has a set of standard counters assigned to it. 범주 둘 이상의 인스턴스 수 있으면 인스턴스 사양 카운터 정보에 포함 되어야 합니다.If a category can have more than one instance, an instance specification must be included in the counter information.

초기 또는 이전 값을 필요한 계산을 수행 하는 데 필요한 카운터에 대 한 성능 데이터를 가져오려면 호출을 NextValue 메서드를 두 번 및 사용 하 여 애플리케이션에 필요한 정보를 반환 합니다.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.

참고

성능 카운터 범주와 함께 설치 된 .NET Framework 2.0.NET Framework 2.0 자체 메모리가 있는 각 성능 카운터 범주를 사용 하 여 별도 공유 메모리를 사용 합니다.Performance counter categories installed with the .NET Framework 2.0.NET Framework 2.0 use separate shared memory, with each performance counter category having its own memory. 레지스트리 키 HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services FileMappingSize 라는 DWORD를 만들어 별도 공유 메모리의 크기를 지정할 수 있습니다\<범주 이름 > \ 성능을 제공 합니다.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. FileMappingSize 값 범주의 공유 메모리 크기 설정 됩니다.The FileMappingSize value is set to the shared memory size of the category. 기본 크기는 10 진수 131072입니다.The default size is 131072 decimal. FileMappingSize 값 없는 경우는 fileMappingSize 특성에 대 한 값을 performanceCounters 합니다 Machine.config 파일에 지정 된 요소를 사용할 구성 파일을 처리에 대 한 추가 오버 헤드를 유발 합니다.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. 레지스트리에서 파일 매핑 크기를 설정 하 여 애플리케이션 시작에 대 한 성능 향상을 이룰 수 있습니다.You can realize a performance improvement for application startup by setting the file mapping size in the registry. 파일 매핑 크기에 대 한 자세한 내용은 참조 하세요. <performanceCounters>합니다.For more information about the file mapping size, see <performanceCounters>.

생성자

PerformanceCounter() PerformanceCounter() PerformanceCounter() PerformanceCounter()

PerformanceCounter 클래스의 새 읽기 전용 인스턴스를 초기화하면서 이 인스턴스를 시스템이나 사용자 지정 성능 카운터와 연결하지 않습니다.Initializes a new, read-only instance of the PerformanceCounter class, without associating the instance with any system or custom performance counter.

PerformanceCounter(String, String) PerformanceCounter(String, String) PerformanceCounter(String, String) PerformanceCounter(String, String)

PerformanceCounter 클래스의 새 읽기 전용 인스턴스를 초기화하고 로컬 컴퓨터의 지정 시스템이나 사용자 지정 성능 카운터에 연결합니다.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. 이 생성자를 사용하려면 범주에 단일 인스턴스가 있어야 합니다.This constructor requires that the category have a single instance.

PerformanceCounter(String, String, Boolean) PerformanceCounter(String, String, Boolean) PerformanceCounter(String, String, Boolean) PerformanceCounter(String, String, Boolean)

PerformanceCounter 클래스의 새 읽기 전용 인스턴스 또는 읽기/쓰기 인스턴스를 초기화하여 로컬 컴퓨터의 지정 시스템이나 사용자 지정 성능 카운터에 연결합니다.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. 이 생성자를 사용하려면 범주에 단일 인스턴스가 있어야 합니다.This constructor requires that the category contain a single instance.

PerformanceCounter(String, String, String) PerformanceCounter(String, String, String) PerformanceCounter(String, String, String) PerformanceCounter(String, String, String)

PerformanceCounter 클래스의 새 읽기 전용 인스턴스를 초기화하여 로컬 컴퓨터의 지정 시스템이나 사용자 지정 성능 카운터 및 범주 인스턴스에 연결합니다.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) PerformanceCounter(String, String, String, Boolean) PerformanceCounter(String, String, String, Boolean) PerformanceCounter(String, String, String, Boolean)

PerformanceCounter 클래스의 새 읽기 전용 또는 읽기/쓰기 인스턴스를 초기화하여 로컬 컴퓨터의 지정 시스템이나 사용자 지정 성능 카운터 및 범주 인스턴스에 연결합니다.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) PerformanceCounter(String, String, String, String) PerformanceCounter(String, String, String, String) PerformanceCounter(String, String, String, String)

PerformanceCounter 클래스의 새 읽기 전용 인스턴스를 초기화하여 특정 컴퓨터의 지정 시스템이나 사용자 지정 성능 카운터 및 범주 인스턴스에 연결합니다.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.

필드

DefaultFileMappingSize DefaultFileMappingSize DefaultFileMappingSize DefaultFileMappingSize

성능 카운터에서 공유하는 전역 메모리의 크기(바이트)를 지정합니다.Specifies the size, in bytes, of the global memory shared by performance counters. 기본 크기는 524,288바이트입니다.The default size is 524,288 bytes.

속성

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

구성 요소가 이벤트를 발생시킬 수 있는지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
CategoryName CategoryName CategoryName CategoryName

이 성능 카운터에 대한 성능 카운터 범주의 이름을 가져오거나 설정합니다.Gets or sets the name of the performance counter category for this performance counter.

Container Container Container Container

IContainer가 포함된 Component를 가져옵니다.Gets the IContainer that contains the Component.

(Inherited from Component)
CounterHelp CounterHelp CounterHelp CounterHelp

이 성능 카운터에 대한 설명을 가져옵니다.Gets the description for this performance counter.

CounterName CounterName CounterName CounterName

PerformanceCounter 인스턴스와 연결된 성능 카운터의 이름을 가져오거나 설정합니다.Gets or sets the name of the performance counter that is associated with this PerformanceCounter instance.

CounterType CounterType CounterType CounterType

관련된 성능 카운터의 카운터 형식을 가져옵니다.Gets the counter type of the associated performance counter.

DesignMode DesignMode DesignMode DesignMode

Component가 현재 디자인 모드인지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
Events Events Events Events

Component에 연결된 이벤트 처리기의 목록을 가져옵니다.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
InstanceLifetime InstanceLifetime InstanceLifetime InstanceLifetime

프로세스의 수명을 가져오거나 설정합니다.Gets or sets the lifetime of a process.

InstanceName InstanceName InstanceName InstanceName

이 성능 카운터에 대한 인스턴스 이름을 가져오거나 설정합니다.Gets or sets an instance name for this performance counter.

MachineName MachineName MachineName MachineName

이 성능 카운터에 대한 컴퓨터 이름을 가져오거나 설정합니다.Gets or sets the computer name for this performance counter

RawValue RawValue RawValue RawValue

이 카운터의 원시 값 또는 계산되지 않은 값을 가져오거나 설정합니다.Gets or sets the raw, or uncalculated, value of this counter.

ReadOnly ReadOnly ReadOnly ReadOnly

PerformanceCounter 인스턴스가 읽기 전용 모드에 있는지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value indicating whether this PerformanceCounter instance is in read-only mode.

Site Site Site Site

ComponentISite를 가져오거나 설정합니다.Gets or sets the ISite of the Component.

(Inherited from Component)

메서드

BeginInit() BeginInit() BeginInit() BeginInit()

폼 또는 다른 구성 요소에서 사용하는 PerformanceCounter 인스턴스의 초기화를 시작합니다.Begins the initialization of a PerformanceCounter instance used on a form or by another component. 초기화는 런타임에 발생합니다.The initialization occurs at runtime.

Close() Close() Close() Close()

성능 카운터를 닫고 이 성능 카운터 인스턴스가 할당한 모든 리소스를 해제합니다.Closes the performance counter and frees all the resources allocated by this performance counter instance.

CloseSharedResources() CloseSharedResources() CloseSharedResources() CloseSharedResources()

카운터에서 할당한 성능 카운터 라이브러리의 공유 상태를 해제합니다.Frees the performance counter library shared state allocated by the counters.

CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

원격 개체와 통신하는 데 사용되는 프록시 생성에 필요한 모든 관련 정보가 들어 있는 개체를 만듭니다.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Decrement() Decrement() Decrement() Decrement()

효율적인 원자 단위 연산을 통해 관련 성능 카운터를 1씩 감소시킵니다.Decrements the associated performance counter by one through an efficient atomic operation.

Dispose() Dispose() Dispose() Dispose()

Component에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the Component.

(Inherited from Component)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Component에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다.Releases the unmanaged resources used by the Component and optionally releases the managed resources.

(Inherited from Component)
EndInit() EndInit() EndInit() EndInit()

폼 또는 다른 구성 요소에서 사용하는 PerformanceCounter 인스턴스의 초기화를 끝냅니다.Ends the initialization of a PerformanceCounter instance that is used on a form or by another component. 초기화는 런타임에 발생합니다.The initialization occurs at runtime.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

이 인스턴스의 수명 정책을 제어하는 현재의 수명 서비스 개체를 검색합니다.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetService(Type) GetService(Type) GetService(Type) GetService(Type)

Component 또는 해당 Container에서 제공하는 서비스를 나타내는 개체를 반환합니다.Returns an object that represents a service provided by the Component or by its Container.

(Inherited from Component)
GetType() GetType() GetType() GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(Inherited from Object)
Increment() Increment() Increment() Increment()

효율적인 원자 단위 연산을 통해 관련 성능 카운터를 1씩 증가시킵니다.Increments the associated performance counter by one through an efficient atomic operation.

IncrementBy(Int64) IncrementBy(Int64) IncrementBy(Int64) IncrementBy(Int64)

효율적인 원자 단위 연산을 통해 관련 성능 카운터의 값을 지정한 양 만큼 증가 또는 감소시킵니다.Increments or decrements the value of the associated performance counter by a specified amount through an efficient atomic operation.

InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

이 인스턴스의 수명 정책을 제어하는 수명 서비스 개체를 가져옵니다.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

현재 MarshalByRefObject 개체의 단순 복사본을 만듭니다.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
NextSample() NextSample() NextSample() NextSample()

카운터 샘플을 가져와서 이에 대한 원시 값 또는 계산되지 않은 값을 반환합니다.Obtains a counter sample, and returns the raw, or uncalculated, value for it.

NextValue() NextValue() NextValue() NextValue()

카운터 샘플을 가져와 계산된 값을 반환합니다.Obtains a counter sample and returns the calculated value for it.

RemoveInstance() RemoveInstance() RemoveInstance() RemoveInstance()

PerformanceCounter 개체의 InstanceName 속성에서 지정한 범주 인스턴스를 삭제합니다.Deletes the category instance specified by the PerformanceCounter object InstanceName property.

ToString() ToString() ToString() ToString()

Component의 이름이 포함된 String을 반환합니다(있는 경우).Returns a String containing the name of the Component, if any. 이 메서드는 재정의할 수 없습니다.This method should not be overridden.

(Inherited from Component)

이벤트

Disposed Disposed Disposed Disposed

Dispose() 메서드를 호출하여 구성 요소가 삭제되는 경우 발생합니다.Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)

적용 대상

추가 정보