PerformanceCounter 类

参考

定义

命名空间:: System.Diagnostics

程序集:: System.Diagnostics.PerformanceCounter.dll

程序集:: System.dll

包:: System.Diagnostics.PerformanceCounter v6.0.0

包:: System.Diagnostics.PerformanceCounter v7.0.0

包:: System.Diagnostics.PerformanceCounter v8.0.0

包:: System.Diagnostics.PerformanceCounter v9.0.0-preview.2.24128.5

Source:: PerformanceCounter.cs

Source:: PerformanceCounter.cs

Source:: PerformanceCounter.cs

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

表示 Windows NT 性能计数器组件。

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

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

type PerformanceCounter = class
    inherit Component
    interface ISupportInitialize

Public NotInheritable Class PerformanceCounter
Inherits Component
Implements ISupportInitialize

继承: Object

MarshalByRefObject

Component
PerformanceCounter

实现: ISupportInitialize

示例

下面的代码示例演示如何使用 PerformanceCounter 类来创建和使用 AverageCount64 计数器类型。该示例创建类别、设置计数器、从计数器收集数据，并调用 CounterSampleCalculator 类来解释性能计数器数据。中间结果和最终结果显示在控制台窗口中。有关其他性能计数器类型的其他示例，请参阅 PerformanceCounterType 枚举。

#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

注解

组件 PerformanceCounter 可用于读取现有的预定义计数器或自定义计数器，以及发布 (将) 性能数据写入自定义计数器。

Windows 性能监视器的“添加计数器”对话框中列出了许多预定义的计数器。若要了解.NET Framework性能计数器，请参阅性能计数器。

此类型实现 IDisposable 接口。在使用完类型后，您应直接或间接释放类型。若要直接释放类型，请在 try/catch 块中调用其 Dispose 方法。若要间接释放类型，请使用 using（在 C# 中）或 Using（在 Visual Basic 中）等语言构造。有关详细信息，请参阅 IDisposable 接口主题中的“使用实现 IDisposable 的对象”一节。

重要

在 .NET Framework 1.0 和 1.1 版本中，此类要求直接调用方是完全受信任的。从 .NET Framework 版本 2.0 开始，此类需要PerformanceCounterPermission特定操作。 PerformanceCounterPermission强烈建议不要向半受信任的代码授予。读取和写入性能计数器的功能允许代码执行一些操作，例如枚举执行的进程并获取有关它们的信息。

此外，将 PerformanceCounter 对象传递给不太受信任的代码可能会造成安全问题。切勿将性能计数器对象（如 PerformanceCounterCategory 或 PerformanceCounter）传递给不太受信任的代码。

若要从性能计数器读取，请创建类的 PerformanceCounter 实例，设置 CategoryName、 CounterName和（可选 InstanceName ）或 MachineName 属性，然后调用 NextValue 方法以读取性能计数器。

若要发布性能计数器数据，请使用 PerformanceCounterCategory.Create 方法创建一个或多个自定义计数器，创建类的 PerformanceCounter 实例，设置 CategoryName、 CounterName 和（可选 InstanceName ）或 MachineName 属性，然后调用 IncrementBy、 Increment或 Decrement 方法，或设置 RawValue 属性以更改自定义计数器的值。

注意

Increment、 IncrementBy和 Decrement 方法使用互锁来更新计数器值。这有助于在多线程或多进程方案中保持计数器值的准确性，但也会导致性能损失。如果不需要互锁操作提供的准确性，可以直接更新属性， RawValue 将性能提升最多 5 倍。但是，在多线程方案中，可能会忽略计数器值的某些更新，从而导致数据不准确。

计数器是收集性能数据的机制。注册表存储所有计数器的名称，每个计数器都与系统功能的特定区域相关。示例包括处理器的繁忙时间、内存使用情况或通过网络连接接收的字节数。

每个计数器通过其名称和位置进行唯一标识。与文件路径包含驱动器、目录、一个或多个子目录和文件名一样，计数器信息由四个元素组成：计算机、类别、类别实例和计数器名称。

计数器信息必须包括计数器度量其数据的类别或性能对象。计算机的类别包括物理组件，例如处理器、磁盘和内存。还有系统类别，例如进程和线程。每个类别都与计算机中的一个功能元素相关，并为其分配了一组标准计数器。这些对象在 Windows 2000 系统监视器中“添加计数器”对话框的“性能对象”下拉列表中列出，你必须将它们包含在计数器路径中。性能数据按与其相关的类别分组。

在某些情况下，可以存在同一类别的多个副本。例如，多个进程和线程同时运行，某些计算机包含多个处理器。类别副本称为类别实例，每个实例分配有一组标准计数器。如果一个类别可以有多个实例，则必须在计数器信息中包含实例规范。

若要获取需要初始值或上一个值来执行必要计算的计数器的性能数据，请调用 NextValue 方法两次，并使用应用程序所需的返回的信息。

注意

随 .NET Framework 2.0 一起安装的性能计数器类别使用单独的共享内存，每个性能计数器类别都有自己的内存。可以通过在注册表项中创建名为 FileMappingSize 的 DWORD 来指定单独的共享内存的大小，HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<类别名称>\Performance。 FileMappingSize 值设置为类别的共享内存大小。默认大小为十进制131072。如果 FileMappingSize 值不存在，则 fileMappingSize 使用 Machine.config 文件中指定的元素的属性值 performanceCounters ，从而导致配置文件处理的额外开销。可以通过在注册表中设置文件映射大小来实现应用程序启动的性能改进。有关文件映射大小的详细信息，请参阅 <performanceCounters>。

构造函数

PerformanceCounter()	初始化 PerformanceCounter 类的新的只读实例，但不将该实例与任何系统性能计数器或自定义性能计数器关联。
PerformanceCounter(String, String)	初始化 PerformanceCounter 类的新的只读实例，并将其与本地计算机上指定的系统性能计数器或自定义性能计数器关联。此构造函数要求该类别包含单个实例。
PerformanceCounter(String, String, Boolean)	初始化 PerformanceCounter 类的新的只读或读/写实例，并将其与本地计算机上指定的系统性能计数器或自定义性能计数器关联。此构造函数要求该类别包含单个实例。
PerformanceCounter(String, String, String)	初始化 PerformanceCounter 类的新的只读实例，并将其与本地计算机上指定的系统性能计数器或自定义性能计数器及类别实例关联。
PerformanceCounter(String, String, String, Boolean)	初始化 PerformanceCounter 类的新的只读实例或读/写实例，并将其与本地计算机上指定的系统性能计数器或自定义性能计数器及类别实例关联。
PerformanceCounter(String, String, String, String)	初始化 PerformanceCounter 类的新的只读实例，并将其与指定计算机上指定的系统性能计数器或自定义性能计数器及类别实例关联。

字段

DefaultFileMappingSize

已过时.

指定由性能计数器共享的全局内存的大小（以字节为单位）。默认大小为 524,288 个字节。

属性

CanRaiseEvents	获取一个指示组件是否可以引发事件的值。 (继承自 Component)
CategoryName	获取或设置此性能计数器的性能计数器类别的名称。
Container	获取包含 IContainer 的 Component。 (继承自 Component)
CounterHelp	获取此性能计数器的说明。
CounterName	获取或设置与此 PerformanceCounter 实例关联的性能计数器的名称。
CounterType	获取关联的性能计数器的计数器类型。
DesignMode	获取一个值，用以指示 Component 当前是否处于设计模式。 (继承自 Component)
Events	获取附加到此 Component 的事件处理程序的列表。 (继承自 Component)
InstanceLifetime	获取或设置进程的生存期。
InstanceName	获取或设置此性能计数器的实例名称。
MachineName	获取或设置此性能计数器的计算机名。
RawValue	获取或设置此计数器的原始值（即未经过计算的值）。
ReadOnly	获取或设置一个值，该值指示此 PerformanceCounter 实例是否处于只读模式。
Site	获取或设置 Component 的 ISite。 (继承自 Component)

方法

BeginInit()	开始初始化在窗体上使用或由另一个组件使用的 PerformanceCounter 实例。此初始化在运行时发生。
Close()	关闭性能计数器并释放由此性能计数器实例分配的所有资源。
CloseSharedResources()	释放由计数器分配的性能计数器库共享状态。
CreateObjRef(Type)	创建一个对象，该对象包含生成用于与远程对象进行通信的代理所需的全部相关信息。 (继承自 MarshalByRefObject)
Decrement()	通过有效的原子操作使关联的性能计数器减一。
Dispose()	释放由 Component 使用的所有资源。 (继承自 Component)
Dispose(Boolean)	释放由 Component 占用的非托管资源，还可以另外再释放托管资源。 (继承自 Component)
EndInit()	结束在窗体上使用或由另一组件使用的 PerformanceCounter 实例的初始化。此初始化在运行时发生。
Equals(Object)	确定指定对象是否等于当前对象。 (继承自 Object)
GetHashCode()	作为默认哈希函数。 (继承自 Object)
GetLifetimeService()	已过时. 检索控制此实例的生存期策略的当前生存期服务对象。 (继承自 MarshalByRefObject)
GetService(Type)	返回一个对象，该对象表示由 Component 或它的 Container 提供的服务。 (继承自 Component)
GetType()	获取当前实例的 Type。 (继承自 Object)
Increment()	通过有效的原子操作使关联的性能计数器增加一。
IncrementBy(Int64)	通过有效的原子操作，使关联的性能计数器的值增加或减少指定的量。
InitializeLifetimeService()	已过时. 获取生存期服务对象来控制此实例的生存期策略。 (继承自 MarshalByRefObject)
MemberwiseClone()	创建当前 Object 的浅表副本。 (继承自 Object)
MemberwiseClone(Boolean)	创建当前 MarshalByRefObject 对象的浅表副本。 (继承自 MarshalByRefObject)
NextSample()	获取计数器样本，并为其返回原始值（即未经过计算的值）。
NextValue()	获取计数器样本并为其返回计算所得值。
RemoveInstance()	删除由 PerformanceCounter 对象的 InstanceName 属性指定的类别实例。
ToString()	返回包含 Component 的名称的 String（如果有）。不应重写此方法。 (继承自 Component)

事件

Disposed

在通过调用 Dispose() 方法释放组件时发生。

(继承自 Component)

适用于

通过

PerformanceCounter 类

定义

示例

注解

构造函数

字段

属性

方法

事件

适用于

另请参阅

其他资源