PerformanceCounter クラス

定義

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
継承
PerformanceCounter
実装

次のコード例は、クラスを使用して 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 パフォーマンスカウンターの読み取りを実行します。

パフォーマンスカウンターデータをパブリッシュするには、メソッドを使用して1つ以上のカスタムカウンターを作成し、 PerformanceCounterCategory.Create クラスのインスタンスを作成します。次に、、、 PerformanceCounter CategoryName CounterName および、オプション、またはプロパティを設定してから、、、またはの各 InstanceName メソッドを呼び出します MachineName 。または、 IncrementBy Increment Decrement RawValue カスタムカウンターの値を変更するようにプロパティを設定します。

注意

、、およびの各メソッドでは、 Increment IncrementBy Decrement interlocks を使用してカウンター値を更新します。 これにより、マルチスレッドまたはマルチプロセスのシナリオでカウンター値を正確に保つことができますが、パフォーマンスが低下します。 インタロック操作によって提供される精度が不要な場合は、 RawValue 最大5倍のパフォーマンス向上のためにプロパティを直接更新できます。 ただし、マルチスレッドのシナリオでは、カウンター値に対するいくつかの更新が無視され、データが不正確になる可能性があります。

このカウンターは、パフォーマンスデータを収集するメカニズムです。 レジストリには、すべてのカウンターの名前が格納されます。各カウンターは、システム機能の特定の領域に関連しています。 例としては、プロセッサのビジー時間、メモリの使用量、ネットワーク接続経由で受信したバイト数などがあります。

各カウンターは、名前とその位置によって一意に識別されます。 ファイルパスには、ドライブ、ディレクトリ、1つ以上のサブディレクトリ、およびファイル名が含まれているのと同じように、カウンター情報は、コンピューター、カテゴリ、カテゴリインスタンス、およびカウンター名の4つの要素で構成されます。

カウンター情報には、カウンターでデータを測定するカテゴリ (パフォーマンスオブジェクト) が含まれている必要があります。 コンピューターのカテゴリには、プロセッサ、ディスク、メモリなどの物理コンポーネントが含まれます。 また、プロセスやスレッドなどのシステムカテゴリもあります。 各カテゴリは、コンピューター内の機能要素に関連付けられており、一連の標準カウンターが割り当てられています。 これらのオブジェクトは、Windows 2000 システムモニター内の [カウンターの追加] ダイアログボックスの [パフォーマンス] オブジェクトボックスの一覧に表示されます。これらのオブジェクトは、カウンターパスに含める必要があります。 パフォーマンスデータは、関連付けられているカテゴリ別にグループ化されます。

場合によっては、同じカテゴリの複数のコピーを存在させることができます。 たとえば、複数のプロセスとスレッドが同時に実行され、一部のコンピューターには複数のプロセッサが含まれているとします。 カテゴリのコピーは category インスタンスと呼ばれ、各インスタンスには一連の標準カウンターが割り当てられます。 カテゴリに複数のインスタンスを含めることができる場合は、インスタンスの指定がカウンター情報に含まれている必要があります。

必要な計算を実行するために初期値または以前の値が必要なカウンターのパフォーマンスデータを取得するには、 NextValue メソッドを2回呼び出し、アプリケーションで必要とされる情報を使用します。

注意

.NET Framework 2.0 と共にインストールされるパフォーマンスカウンターカテゴリには個別の共有メモリが使用され、各パフォーマンスカウンターカテゴリには独自のメモリがあります。 レジストリキーに FileMappingSize という名前の DWORD を作成することによって、個別の共有メモリのサイズを指定することができ \ <category name> ます HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services。 FileMappingSize 値は、カテゴリの共有メモリサイズに設定されます。 既定のサイズは 131072 decimal です。 FileMappingSize 値が指定されていない場合、 fileMappingSize performanceCounters Machine.config ファイルに指定されている要素の属性値が使用され、構成ファイルの処理に追加のオーバーヘッドが発生します。 アプリケーションの起動のパフォーマンスを向上させるには、レジストリでファイルマッピングサイズを設定します。 ファイルマッピングサイズの詳細については、「 < performanceCounters > 」を参照してください。

コンストラクター

PerformanceCounter()

システム パフォーマンス カウンターにもカスタム パフォーマンス カウンターにも関連付けずに、PerformanceCounter クラスの新しい読み取り専用インスタンスを初期化します。

PerformanceCounter(String, String)

PerformanceCounter クラスの新しい読み取り専用インスタンスを初期化し、ローカル コンピューターの指定したシステム パフォーマンス カウンターまたはカスタム パフォーマンス カウンターに関連付けます。 このコンストラクターを使用するには、カテゴリに含まれるインスタンスが 1 つだけである必要があります。

PerformanceCounter(String, String, Boolean)

PerformanceCounter クラスの新しい読み取り専用インスタンスまたは読み取り/書き込み可能インスタンスを初期化し、ローカル コンピューターの指定したシステム パフォーマンス カウンターまたはカスタム パフォーマンス カウンターに関連付けます。 このコンストラクターを使用するには、カテゴリに含まれるインスタンスが 1 つだけである必要があります。

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

ComponentISite を取得または設定します。

(継承元 Component)

メソッド

BeginInit()

フォームまたは別のコンポーネントで使用する PerformanceCounter インスタンスの初期化を開始します。 初期化は実行時に発生します。

Close()

パフォーマンス カウンターを閉じ、このパフォーマンス カウンター インスタンスで割り当てられたすべてのリソースを解放します。

CloseSharedResources()

カウンターによって割り当てられた共有状態のパフォーマンス カウンター ライブラリを解放します。

CreateObjRef(Type)

リモート オブジェクトとの通信に使用するプロキシの生成に必要な情報をすべて格納しているオブジェクトを作成します。

(継承元 MarshalByRefObject)
Decrement()

有効な分割不可能な操作を通じて、関連付けられたパフォーマンス カウンターを 1 ずつデクリメントします。

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()

有効な分割不可能な操作を通じて、関連付けられたパフォーマンス カウンターを 1 ずつインクリメントします。

IncrementBy(Int64)

有効な分割不可能な操作を通じて、関連付けられたパフォーマンス カウンターの値を指定した量ずつインクリメントまたはデクリメントします。

InitializeLifetimeService()
互換性のために残されています。

このインスタンスの有効期間ポリシーを制御する有効期間サービス オブジェクトを取得します。

(継承元 MarshalByRefObject)
MemberwiseClone()

現在の Object の簡易コピーを作成します。

(継承元 Object)
MemberwiseClone(Boolean)

現在の MarshalByRefObject オブジェクトの簡易コピーを作成します。

(継承元 MarshalByRefObject)
NextSample()

カウンター サンプルを取得し、生の、つまり計算されない値を返します。

NextValue()

カウンター サンプルを取得し、計算される値を返します。

RemoveInstance()

PerformanceCounter オブジェクトの InstanceName プロパティで指定されたカテゴリ インスタンスを削除します。

ToString()

Component の名前 (存在する場合) を格納する String を返します。 このメソッドはオーバーライドできません。

(継承元 Component)

イベント

Disposed

Dispose() メソッドの呼び出しによってコンポーネントが破棄されるときに発生します。

(継承元 Component)

適用対象

こちらもご覧ください