CounterCreationDataCollectionとは？ わかりやすく解説

.NET Framework クラス ライブラリ リファレンス
索引トップ 用語の索引 ランキング
日本マイクロソフト株式会社日本マイクロソフト株式会社

CounterCreationDataCollection クラス

CounterCreationData オブジェクトの厳密に型指定されたコレクションを提供します。

名前空間: System.Diagnostics
アセンブリ: System (system.dll 内)
構文構文

Visual Basic (宣言)
<SerializableAttribute> _
Public Class CounterCreationDataCollection
    Inherits CollectionBase
Visual Basic (使用法)
Dim instance As CounterCreationDataCollection
C#
[SerializableAttribute] 
public class CounterCreationDataCollection
 : CollectionBase
C++
[SerializableAttribute] 
public ref class CounterCreationDataCollection
 : public CollectionBase
J#
/** @attribute SerializableAttribute() */ 
public class CounterCreationDataCollection
 extends CollectionBase
JScript
SerializableAttribute 
public class CounterCreationDataCollection
 extends CollectionBase
使用例使用例
Visual Basic
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class App
   
   Private Shared PC As
 PerformanceCounter
   Private Shared BPC As
 PerformanceCounter
   
   
   Public Shared Sub Main()
      
      Dim samplesList As New
 ArrayList()
      
      SetupCategory()
      CreateCounters()
      CollectSamples(samplesList)
      CalculateResults(samplesList)
   End Sub 'Main
    
   
   
   Private Shared Function
 SetupCategory() As Boolean
      If Not PerformanceCounterCategory.Exists("AverageCounter64SampleCategory")
 Then
         
         Dim CCDC As New
 CounterCreationDataCollection()
         
         ' Add the counter.
         Dim averageCount64 As New
 CounterCreationData()
         averageCount64.CounterType = PerformanceCounterType.AverageCount64
         averageCount64.CounterName = "AverageCounter64Sample"
         CCDC.Add(averageCount64)
         
         ' Add the base counter.
         Dim averageCount64Base As New
 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
      End If
   End Function 'SetupCategory
   
   
   Private Shared Sub CreateCounters()
      ' Create the counters.

      PC = New PerformanceCounter("AverageCounter64SampleCategory",
 "AverageCounter64Sample", False)
      
      BPC = New PerformanceCounter("AverageCounter64SampleCategory",
 "AverageCounter64SampleBase", False)
      
      
      PC.RawValue = 0
      BPC.RawValue = 0
   End Sub 'CreateCounters
   
   
   Private Shared Sub CollectSamples(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 + " = " + value))
         
         PC.IncrementBy(value)
         
         BPC.Increment()
         
         If j Mod 10 = 9 Then
            OutputSample(PC.NextSample())
            samplesList.Add(PC.NextSample())
         Else
            Console.WriteLine()
         End If 
         System.Threading.Thread.Sleep(50)
      Next j
   End Sub 'CollectSamples
    
   
   Private Shared Sub CalculateResults(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))))
         
         ' Calculate the counter value manually.
         Console.WriteLine(("My computed counter value = "
 + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i
 + 1)), CounterSample))))
      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(s0 As CounterSample, 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(s
 As CounterSample)
      Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
      Console.WriteLine("Sample values - " + ControlChars.Lf
 + ControlChars.Cr)
      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("++++++++++++++++++++++")
   End Sub 'OutputSample
End Class 'App
C#
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class App {

    private static PerformanceCounter PC;
    private static PerformanceCounter BPC;

    public static void Main()
    {    
    
        ArrayList samplesList = new ArrayList();

        SetupCategory();
        CreateCounters();
        CollectSamples(samplesList);
        CalculateResults(samplesList);

    }
    

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

            CounterCreationDataCollection CCDC = new CounterCreationDataCollection();
            
            // Add the counter.
            CounterCreationData averageCount64 = new CounterCreationData();
            averageCount64.CounterType = PerformanceCounterType.AverageCount64;
            averageCount64.CounterName = "AverageCounter64Sample";
            CCDC.Add(averageCount64);
            
            // Add the base counter.
            CounterCreationData averageCount64Base = new 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);
        }
    }
    
    private static void
 CreateCounters()
    {
        // Create the counters.

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

        BPC = new PerformanceCounter("AverageCounter64SampleCategory",
 
            "AverageCounter64SampleBase", 
            false);
        
        
        PC.RawValue=0;
        BPC.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);

            PC.IncrementBy(value);

            BPC.Increment();

            if ((j % 10) == 9) 
            {
                OutputSample(PC.NextSample());
                samplesList.Add( PC.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("++++++++++++++++++++++");
    }
}
C++
#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 );
}
J#
import System.*;  
import System.Collections.*;  
import System.Collections.Specialized.*;  
import System.Diagnostics.*;  

public class App
{
    private static PerformanceCounter pc;
    private static PerformanceCounter bpc;

    public static void main(String[]
 args)
    {
        ArrayList samplesList = new ArrayList();
        SetupCategory();
        CreateCounters();
        CollectSamples(samplesList);
        CalculateResults(samplesList);
    } //main

    private static boolean SetupCategory()
    {
        if (!(PerformanceCounterCategory.Exists(
            "AverageCounter64SampleCategory"))) {
            CounterCreationDataCollection ccdc = 
                new CounterCreationDataCollection();
            // Add the counter.
            CounterCreationData averageCount64 = new CounterCreationData();
            averageCount64.
                set_CounterType(PerformanceCounterType.AverageCount64);
            averageCount64.set_CounterName("AverageCounter64Sample");
            ccdc.Add(averageCount64);
            // Add the base counter.
            CounterCreationData averageCount64Base = new CounterCreationData();
            averageCount64Base.set_CounterType(PerformanceCounterType.
                AverageBase);
            averageCount64Base.set_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;
        }
    } //SetupCategory

    private static void
 CreateCounters()
    {
        // Create the counters.
        pc = new PerformanceCounter("AverageCounter64SampleCategory"
,
            "AverageCounter64Sample", false);
        bpc = new PerformanceCounter("AverageCounter64SampleCategory"
,
            "AverageCounter64SampleBase", false);
        pc.set_RawValue(0);
        bpc.set_RawValue(0);
    } //CreateCounters

    private static void
 CollectSamples(ArrayList samplesList)
    {
        Random r = new Random(DateTime.get_Now().get_Millisecond());
        // Loop for the samples.
        for (int j = 0; j < 100; j++) {
            int value = r.Next(1, 10);
            Console.Write(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);
        }
    } //CollectSamples

    private static void
 CalculateResults(ArrayList samplesList)
    {
        for (int i = 0; i < samplesList.get_Count()
 - 1; i++) {
            // Output the sample.
            OutputSample((CounterSample)samplesList.get_Item(i));
            OutputSample((CounterSample)samplesList.get_Item(i + 1));
            // Use.NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " 
                + CounterSampleCalculator.ComputeCounterValue((CounterSample)
                samplesList.get_Item(i), 
                (CounterSample)samplesList.get_Item(i + 1)));
            // Calculate the counter value manually.
            Console.WriteLine("My computed counter value = "
                + MyComputeCounterValue((CounterSample)samplesList.get_Item(i),
                (CounterSample)samplesList.get_Item(i + 1)));
        }
    } //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 static float
 MyComputeCounterValue(CounterSample s0,
        CounterSample s1)
    {
        float numerator = (float)s1.get_RawValue()
 - (float)s0.get_RawValue();
        float denomenator = (float)s1.get_BaseValue()
 - (float)s0.
            get_BaseValue();
        float counterValue = numerator / denomenator;
        return counterValue;
    } //MyComputeCounterValue

    // 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.get_BaseValue());
        Console.WriteLine("   CounterFrequency = " + s.get_CounterFrequency());
        Console.WriteLine("   CounterTimeStamp = " + s.get_CounterTimeStamp());
        Console.WriteLine("   CounterType      = " + s.get_CounterType());
        Console.WriteLine("   RawValue         = " + s.get_RawValue());
        Console.WriteLine("   SystemFrequency  = " + s.get_SystemFrequency());
        Console.WriteLine("   TimeStamp        = " + s.get_TimeStamp());
        Console.WriteLine("   TimeStamp100nSec = " + s.get_TimeStamp100nSec());
        Console.WriteLine("++++++++++++++++++++++");
    } //OutputSample
} //App
継承階層継承階層
System.Object
   System.Collections.CollectionBase
    System.Diagnostics.CounterCreationDataCollection
スレッド セーフスレッド セーフ
この型の public static (Visual Basic では Shared) メンバはすべて、スレッド セーフです。インスタンス メンバの場合は、スレッド セーフであるとは限りません。
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0、1.1、1.0
参照参照
関連項目
CounterCreationDataCollection メンバ
System.Diagnostics 名前空間

CounterCreationDataCollection コンストラクタ ()

CounterCreationData インスタンスに関連付けずに、CounterCreationDataCollection クラスの新しいインスタンスを初期化します。

名前空間: System.Diagnostics
アセンブリ: System (system.dll 内)
構文構文

Visual Basic (宣言)
Public Sub New
Visual Basic (使用法)
Dim instance As New CounterCreationDataCollection
C#
public CounterCreationDataCollection ()
C++
public:
CounterCreationDataCollection ()
J#
public CounterCreationDataCollection ()
JScript
public function CounterCreationDataCollection
 ()
使用例使用例
Visual Basic
Imports System
Imports System.Diagnostics

Public Class CounterDataCollectionExample
   Private Shared myCounter As
 PerformanceCounter
   Public Shared Sub Main()
      Try

         Dim myCategoryName As String
         Dim numberOfCounters As Integer
         Console.Write("Enter the number of counters : ")
         numberOfCounters = Integer.Parse(Console.ReadLine())
         Dim myCounterCreationData(numberOfCounters-1) As
 CounterCreationData
         Dim i As Integer
         For i = 0 To numberOfCounters - 1
            Console.Write("Enter the counter name for {0} counter
 : ", i)
            myCounterCreationData(i) = New CounterCreationData()
            myCounterCreationData(i).CounterName = Console.ReadLine()
         Next i
         Dim myCounterCollection As New
 CounterCreationDataCollection(myCounterCreationData)
         Console.Write("Enter the category Name : ")
         myCategoryName = Console.ReadLine()
         ' Check if the category already exists or not.
         If Not PerformanceCounterCategory.Exists(myCategoryName)
 Then
            Dim myNewCounterCollection As New
 CounterCreationDataCollection()
            ' Add the 'CounterCreationDataCollection' to 'CounterCreationDataCollection'
 object.
            myNewCounterCollection.AddRange(myCounterCollection)

            PerformanceCounterCategory.Create(myCategoryName, "Sample
 Category", _
                                          myNewCounterCollection)
            For i = 0 To numberOfCounters -
 1
               myCounter = New PerformanceCounter(myCategoryName,
 _
                                 myCounterCreationData(i).CounterName, "",
 False)
            Next i
            Console.WriteLine("The list of counters in CounterCollection
 are: ")

            For i = 0 To myNewCounterCollection.Count
 - 1
               Console.WriteLine("Counter {0} is '{1}'",
 i + 1, _
                                             myNewCounterCollection(i).CounterName)
            Next i
         Else
            Console.WriteLine("The category already exists")
         End If

      Catch e As Exception
         Console.WriteLine("Exception: {0}.", e.Message)
         Return
      End Try
   End Sub 'Main
End Class 'CounterDataCollectionExample
C#
using System;
using System.Diagnostics;

public class CounterDataCollectionExample
{
   static PerformanceCounter myCounter;
   public static void Main()
   {
      try
      {

         string myCategoryName;
         int numberOfCounters;
         Console.Write("Enter the number of counters : ");
         numberOfCounters = int.Parse(Console.ReadLine());
         CounterCreationData[]  myCounterCreationData =
            new CounterCreationData[numberOfCounters];
         for(int i = 0; i < numberOfCounters;
 i++)
         {
            Console.Write("Enter the counter name for {0}
 counter : ", i);
            myCounterCreationData[i] = new CounterCreationData();
            myCounterCreationData[i].CounterName = Console.ReadLine();
         }
         CounterCreationDataCollection myCounterCollection =
            new CounterCreationDataCollection(myCounterCreationData);
         Console.Write("Enter the category Name : ");
         myCategoryName = Console.ReadLine();
         // Check if the category already exists or not.
         if(!PerformanceCounterCategory.Exists(myCategoryName))
         {
            CounterCreationDataCollection myNewCounterCollection =
               new CounterCreationDataCollection();
            // Add the 'CounterCreationDataCollection' to 'CounterCreationDataCollection'
 object.
            myNewCounterCollection.AddRange(myCounterCollection);

            PerformanceCounterCategory.Create(myCategoryName, "Sample Category"
,
               myNewCounterCollection);

            for(int i = 0; i < numberOfCounters;
 i++)
            {
               myCounter = new PerformanceCounter(myCategoryName
,
                  myCounterCreationData[i].CounterName, "", false);
            }
            Console.WriteLine("The list of counters in CounterCollection
 are: ");
            for(int i = 0; i < myNewCounterCollection.Count;
 i++)
               Console.WriteLine("Counter {0} is '{1}'", i+1, myNewCounterCollection[i].CounterName);
         }
         else
         {
            Console.WriteLine("The category already exists");
         }

      }
      catch(Exception e)
      {
         Console.WriteLine("Exception: {0}.", e.Message);
         return;
      }
   }
}
C++
#using <System.dll>

using namespace System;
using namespace System::Diagnostics;
int main()
{
   PerformanceCounter^ myCounter;
   try
   {
      String^ myCategoryName;
      int numberOfCounters;
      Console::Write( "Enter the number of counters : " );
      numberOfCounters = Int32::Parse( Console::ReadLine() );
      array<CounterCreationData^>^myCounterCreationData = gcnew array<CounterCreationData^>(numberOfCounters);
      for ( int i = 0; i < numberOfCounters;
 i++ )
      {
         Console::Write( "Enter the counter name for {0}
 counter : ", i );
         myCounterCreationData[ i ] = gcnew CounterCreationData;
         myCounterCreationData[ i ]->CounterName = Console::ReadLine();
      }
      CounterCreationDataCollection^ myCounterCollection = gcnew CounterCreationDataCollection(
 myCounterCreationData );
      Console::Write( "Enter the category Name : " );
      myCategoryName = Console::ReadLine();

      // Check if the category already exists or not.
      if (  !PerformanceCounterCategory::Exists( myCategoryName
 ) )
      {
         CounterCreationDataCollection^ myNewCounterCollection = gcnew CounterCreationDataCollection;

         // Add the 'CounterCreationDataCollection' to 'CounterCreationDataCollection'
 Object*.
         myNewCounterCollection->AddRange( myCounterCollection );
         PerformanceCounterCategory::Create( myCategoryName, "Sample Category",
 myNewCounterCollection );
         for ( int i = 0; i < numberOfCounters;
 i++ )
         {
            myCounter = gcnew PerformanceCounter( myCategoryName,myCounterCreationData[
 i ]->CounterName,"",false );

         }
         Console::WriteLine( "The list of counters in CounterCollection
 are: " );
         for ( int i = 0; i < myNewCounterCollection->Count;
 i++ )
            Console::WriteLine( "Counter {0} is '{1}'", i + 1, myNewCounterCollection[
 i ]->CounterName );
      }
      else
      {
         Console::WriteLine( "The category already exists" );
      }
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception: {0}.", e->Message );
   }
}
J#
import System.*;
import System.Diagnostics.*;

public class CounterDataCollectionExample
{
    private static PerformanceCounter myCounter;

    public static void main(String[]
 args)
    {
        try {
            String myCategoryName;
            int numberOfCounters;
            Console.Write("Enter the number of counters : ");
            numberOfCounters = Int32.Parse(Console.ReadLine());
            CounterCreationData myCounterCreationData[] = new
 
                CounterCreationData[numberOfCounters];
            for (int i = 0; i < numberOfCounters;
 i++) {
                Console.Write("Enter the counter name for
 {0} counter : ",
                    System.Convert.ToString(i));
                myCounterCreationData.set_Item(i, new CounterCreationData());
                myCounterCreationData[i].set_CounterName(Console.ReadLine());
            }
            CounterCreationDataCollection myCounterCollection = new
 
                CounterCreationDataCollection(myCounterCreationData);
            Console.Write("Enter the category Name : ");
            myCategoryName = Console.ReadLine();
            // Check if the category already exists or not.
            if (!(PerformanceCounterCategory.Exists(myCategoryName)))
 {
                CounterCreationDataCollection myNewCounterCollection = new
 
                    CounterCreationDataCollection();
                // Add the 'CounterCreationDataCollection' to 
                // 'CounterCreationDataCollection' object.
                myNewCounterCollection.AddRange(myCounterCollection);

                PerformanceCounterCategory.Create(myCategoryName, 
                    "Sample Category", myNewCounterCollection);

                for (int i = 0; i < numberOfCounters;
 i++) {
                    myCounter = new PerformanceCounter(myCategoryName
,
                        myCounterCreationData[i].get_CounterName(), "",
 false);
                }
                Console.WriteLine("The list of counters in
 "
                    + "CounterCollection are: ");
                for (int i = 0; i < myNewCounterCollection.get_Count();
 i++) {
                    Console.WriteLine("Counter {0} is '{1}'", 
                        System.Convert.ToString(i + 1),
                        myNewCounterCollection.get_Item(i).get_CounterName());
                }
            }
            else {
                Console.WriteLine("The category already exists");
            }
        }
        catch (System.Exception e) {
            Console.WriteLine("Exception: {0}.", e.get_Message());
            return;
        }
    } //main
} //CounterDataCollectionExample
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0、1.1、1.0
参照参照
関連項目
CounterCreationDataCollection クラス
CounterCreationDataCollection メンバ
System.Diagnostics 名前空間

CounterCreationDataCollection コンストラクタ (CounterCreationData[])

CounterCreationData インスタンスの配列を指定して、CounterCreationDataCollection クラスの新しいインスタンスを初期化します。

名前空間: System.Diagnostics
アセンブリ: System (system.dll 内)
構文構文

Visual Basic (宣言)
Public Sub New ( _
    value As CounterCreationData() _
)
Visual Basic (使用法)
Dim value As CounterCreationData()

Dim instance As New CounterCreationDataCollection(value)
C#
public CounterCreationDataCollection (
    CounterCreationData[] value
)
C++
public:
CounterCreationDataCollection (
    array<CounterCreationData^>^ value
)
J#
public CounterCreationDataCollection (
    CounterCreationData[] value
)
JScript
public function CounterCreationDataCollection
 (
    value : CounterCreationData[]
)

パラメータ

value

この CounterCreationDataCollection を初期化するために使用する CounterCreationData インスタンスの配列。

例外例外
例外の種類条件

ArgumentNullException

value が null 参照 (Visual Basic では Nothing) です。

使用例使用例
Visual Basic
Dim myCategoryName As String
Dim numberOfCounters As Integer
Console.Write("Enter the category Name : ")
myCategoryName = Console.ReadLine()
' Check if the category already exists or not.
If Not PerformanceCounterCategory.Exists(myCategoryName)
 Then
   Console.Write("Enter the number of counters : ")
   numberOfCounters = Integer.Parse(Console.ReadLine())
   Dim myCounterCreationData(numberOfCounters-1) As
 CounterCreationData

   Dim i As Integer
   For i = 0 To numberOfCounters - 1
      Console.Write("Enter the counter name for {0} counter :
 ", i)
      myCounterCreationData(i) = New CounterCreationData()
      myCounterCreationData(i).CounterName = Console.ReadLine()
   Next i
   Dim myCounterCollection As New
 CounterCreationDataCollection(myCounterCreationData)
   ' Create the category.
   PerformanceCounterCategory.Create(myCategoryName, "Sample Category",
 _
                                       myCounterCollection)

   For i = 0 To numberOfCounters - 1
      myCounter = New PerformanceCounter(myCategoryName, _
                              myCounterCreationData(i).CounterName, "",
 False)
   Next i
   Console.WriteLine("The list of counters in
 'CounterCollection' are :")

   For i = 0 To myCounterCollection.Count -
 1
      Console.WriteLine("Counter {0} is '{1}'",
 i, _
                                    myCounterCollection(i).CounterName)
   Next i
Else
   Console.WriteLine("The category already exists")
End If
C#
string myCategoryName;
int numberOfCounters;
Console.Write("Enter the category Name : ");
myCategoryName = Console.ReadLine();
// Check if the category already exists or not.
if(!PerformanceCounterCategory.Exists(myCategoryName))
{
   Console.Write("Enter the number of counters : ");
   numberOfCounters = int.Parse(Console.ReadLine());
   CounterCreationData[]  myCounterCreationData =
      new CounterCreationData[numberOfCounters];

   for(int i = 0; i < numberOfCounters;
 i++)
   {
      Console.Write("Enter the counter name for {0} counter
 : ", i);
      myCounterCreationData[i] = new CounterCreationData();
      myCounterCreationData[i].CounterName = Console.ReadLine();
   }
   CounterCreationDataCollection myCounterCollection =
      new CounterCreationDataCollection(myCounterCreationData);
   // Create the category.
   PerformanceCounterCategory.Create(myCategoryName,
      "Sample Category", myCounterCollection);

   for(int i = 0; i < numberOfCounters;
 i++)
   {
      myCounter = new PerformanceCounter(myCategoryName,
         myCounterCreationData[i].CounterName, "", false);
   }
   Console.WriteLine("The list of counters in 'CounterCollection'
 are :");
   for(int i = 0; i < myCounterCollection.Count;
 i++)
      Console.WriteLine("Counter {0} is '{1}'", i, myCounterCollection[i].CounterName);
}
else
{
   Console.WriteLine("The category already exists");
}
C++
String^ myCategoryName;
int numberOfCounters;
Console::Write( "Enter the category Name : " );
myCategoryName = Console::ReadLine();

// Check if the category already exists or not.
if (  !PerformanceCounterCategory::Exists( myCategoryName ) )
{
   Console::Write( "Enter the number of counters : " );
   numberOfCounters = Int32::Parse( Console::ReadLine() );
   array<CounterCreationData^>^myCounterCreationData = gcnew array<CounterCreationData^>(numberOfCounters);
   for ( int i = 0; i < numberOfCounters;
 i++ )
   {
      Console::Write( "Enter the counter name for {0} counter
 : ", i );
      myCounterCreationData[ i ] = gcnew CounterCreationData;
      myCounterCreationData[ i ]->CounterName = Console::ReadLine();

   }
   CounterCreationDataCollection^ myCounterCollection = gcnew CounterCreationDataCollection(
 myCounterCreationData );
   
   // Create the category.
   PerformanceCounterCategory::Create( myCategoryName, "Sample Category",
 myCounterCollection );
   for ( int i = 0; i < numberOfCounters;
 i++ )
   {
      myCounter = gcnew PerformanceCounter( myCategoryName,myCounterCreationData[
 i ]->CounterName,"",false );

   }
   Console::WriteLine( "The list of counters in 'CounterCollection'
 are :" );
   for ( int i = 0; i < myCounterCollection->Count;
 i++ )
      Console::WriteLine( "Counter {0} is '{1}'", i, myCounterCollection[
 i ]->CounterName );
}
else
{
   Console::WriteLine( "The category already exists" );
}
J#
String myCategoryName;
int numberOfCounters;
Console.Write("Enter the category Name : ");
myCategoryName = Console.ReadLine();
// Check if the category already exists or not.
if (!(PerformanceCounterCategory.Exists(myCategoryName))) {
    Console.Write("Enter the number of counters : ");
    numberOfCounters = Int32.Parse(Console.ReadLine());
    CounterCreationData myCounterCreationData[] = new 
        CounterCreationData[numberOfCounters];

    for (int i = 0; i < numberOfCounters;
 i++) {
        Console.Write("Enter the counter name for {0} counter
 : ",
            System.Convert.ToString(i));
        myCounterCreationData[i] = new CounterCreationData();
        myCounterCreationData[i].set_CounterName(Console.ReadLine());
    }
    CounterCreationDataCollection myCounterCollection = new 
        CounterCreationDataCollection(myCounterCreationData);
    // Create the category.
    PerformanceCounterCategory.Create(myCategoryName, 
        "Sample Category", myCounterCollection);

    for (int i = 0; i < numberOfCounters;
 i++) {
        myCounter = new PerformanceCounter(myCategoryName,
            myCounterCreationData[i].get_CounterName(), "", false);
    }
    Console.WriteLine("The list of counters in "
        + "'CounterCollection' are :");
    for (int i = 0; i < myCounterCollection.get_Count();
 i++) {
        Console.WriteLine("Counter {0} is '{1}'", 
            System.Convert.ToString(i),
            myCounterCollection.get_Item(i).get_CounterName());
    }
}
else {
    Console.WriteLine("The category already exists");
}
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0、1.1、1.0
参照参照
関連項目
CounterCreationDataCollection クラス
CounterCreationDataCollection メンバ
System.Diagnostics 名前空間

CounterCreationDataCollection コンストラクタ (CounterCreationDataCollection)

CounterCreationData インスタンスのコレクションを指定して、CounterCreationDataCollection クラスの新しいインスタンスを初期化します。

名前空間: System.Diagnostics
アセンブリ: System (system.dll 内)
構文構文

Visual Basic (宣言)
Public Sub New ( _
    value As CounterCreationDataCollection _
)
Visual Basic (使用法)
Dim value As CounterCreationDataCollection

Dim instance As New CounterCreationDataCollection(value)
C#
public CounterCreationDataCollection (
    CounterCreationDataCollection value
)
C++
public:
CounterCreationDataCollection (
    CounterCreationDataCollection^ value
)
J#
public CounterCreationDataCollection (
    CounterCreationDataCollection value
)
JScript
public function CounterCreationDataCollection
 (
    value : CounterCreationDataCollection
)

パラメータ

value

この CounterCreationDataCollection を初期化するために使用する CounterCreationData インスタンスが格納されている CounterCreationDataCollection。

例外例外
例外の種類条件

ArgumentNullException

value が null 参照 (Visual Basic では Nothing) です。

使用例使用例
Visual Basic
Dim myCategoryName As String
Dim numberOfCounters As Integer
Console.Write("Enter the number of counters : ")
numberOfCounters = Integer.Parse(Console.ReadLine())
Dim myCounterCreationData(numberOfCounters-1) As
 CounterCreationData
Dim i As Integer
For i = 0 To numberOfCounters - 1
   Console.Write("Enter the counter name for {0} counter : ",
 i)
   myCounterCreationData(i) = New CounterCreationData()
   myCounterCreationData(i).CounterName = Console.ReadLine()
Next i
Dim myCounterCollection As New
 CounterCreationDataCollection(myCounterCreationData)
Console.Write("Enter the category Name:")
myCategoryName = Console.ReadLine()
' Check if the category already exists or not.
If Not PerformanceCounterCategory.Exists(myCategoryName)
 Then
   Dim myNewCounterCollection As New
 CounterCreationDataCollection(myCounterCollection)
   PerformanceCounterCategory.Create(myCategoryName, "Sample Category",
 _
                                          myNewCounterCollection)

   For i = 0 To numberOfCounters - 1
      myCounter = New PerformanceCounter(myCategoryName, _
                     myCounterCreationData(i).CounterName, "",
 False)
   Next i
   Console.WriteLine("The list of counters in
 'CounterCollection' are : ")

   For i = 0 To myNewCounterCollection.Count
 - 1
      Console.WriteLine("Counter {0} is '{1}'",
 i, myNewCounterCollection(i).CounterName)
   Next i
Else
   Console.WriteLine("The category already exists")
End If
C#
string myCategoryName;
int numberOfCounters;
Console.Write("Enter the number of counters : ");
numberOfCounters = int.Parse(Console.ReadLine());
CounterCreationData[]  myCounterCreationData =
   new CounterCreationData[numberOfCounters];
for(int i = 0; i < numberOfCounters; i++)
{
   Console.Write("Enter the counter name for {0} counter
 : ", i);
   myCounterCreationData[i] = new CounterCreationData();
   myCounterCreationData[i].CounterName = Console.ReadLine();
}
CounterCreationDataCollection myCounterCollection =
   new CounterCreationDataCollection(myCounterCreationData);
Console.Write("Enter the category Name:");
myCategoryName = Console.ReadLine();
// Check if the category already exists or not.
if(!PerformanceCounterCategory.Exists(myCategoryName))
{
   CounterCreationDataCollection myNewCounterCollection =
      new CounterCreationDataCollection(myCounterCollection);
   PerformanceCounterCategory.Create(myCategoryName, "Sample Category"
,
      myNewCounterCollection);

   for(int i = 0; i < numberOfCounters;
 i++)
   {
      myCounter = new PerformanceCounter(myCategoryName,
         myCounterCreationData[i].CounterName, "", false);
   }
   Console.WriteLine("The list of counters in 'CounterCollection'
 are : ");
   for(int i = 0; i < myNewCounterCollection.Count;
 i++)
      Console.WriteLine("Counter {0} is '{1}'", i, myNewCounterCollection[i].CounterName);
}
else
{
   Console.WriteLine("The category already exists");
}
C++
String^ myCategoryName;
int numberOfCounters;
Console::Write( "Enter the number of counters : " );
numberOfCounters = Int32::Parse( Console::ReadLine() );
array<CounterCreationData^>^myCounterCreationData = gcnew array<CounterCreationData^>(numberOfCounters);
for ( int i = 0; i < numberOfCounters; i++
 )
{
   Console::Write( "Enter the counter name for {0} counter
 : ", i );
   myCounterCreationData[ i ] = gcnew CounterCreationData;
   myCounterCreationData[ i ]->CounterName = Console::ReadLine();

}
CounterCreationDataCollection^ myCounterCollection = gcnew CounterCreationDataCollection(
 myCounterCreationData );
Console::Write( "Enter the category Name:" );
myCategoryName = Console::ReadLine();

// Check if the category already exists or not.
if (  !PerformanceCounterCategory::Exists( myCategoryName ) )
{
   CounterCreationDataCollection^ myNewCounterCollection = gcnew CounterCreationDataCollection(
 myCounterCollection );
   PerformanceCounterCategory::Create( myCategoryName, "Sample Category",
 myNewCounterCollection );
   for ( int i = 0; i < numberOfCounters; i++
 )
   {
      myCounter = gcnew PerformanceCounter( myCategoryName,myCounterCreationData[
 i ]->CounterName,"",false );

   }
   Console::WriteLine( "The list of counters in 'CounterCollection'
 are : " );
   for ( int i = 0; i < myNewCounterCollection->Count;
 i++ )
      Console::WriteLine( "Counter {0} is '{1}'", i, myNewCounterCollection[
 i ]->CounterName );
}
else
{
   Console::WriteLine( "The category already exists" );
}
J#
String myCategoryName;
int numberOfCounters;
Console.Write("Enter the number of counters : ");
numberOfCounters = Int32.Parse(Console.ReadLine());
CounterCreationData myCounterCreationData[] = new 
    CounterCreationData[numberOfCounters];
for (int i = 0; i < numberOfCounters; i++)
 {
    Console.Write("Enter the counter name for {0} counter
 : ",
        System.Convert.ToString(i));
    myCounterCreationData.set_Item(i, new CounterCreationData());
    myCounterCreationData[i].set_CounterName(Console.ReadLine());
}
CounterCreationDataCollection myCounterCollection = new 
    CounterCreationDataCollection(myCounterCreationData);
Console.Write("Enter the category Name:");
myCategoryName = Console.ReadLine();
// Check if the category already exists or not.
if (!(PerformanceCounterCategory.Exists(myCategoryName))) {
    CounterCreationDataCollection myNewCounterCollection = new
        CounterCreationDataCollection(myCounterCollection);
    PerformanceCounterCategory.Create(myCategoryName, 
        "Sample Category", myNewCounterCollection);

    for (int i = 0; i < numberOfCounters; i++)
 {
        myCounter = new PerformanceCounter(myCategoryName,
            myCounterCreationData[i].get_CounterName(), "", false);
    }
    Console.WriteLine("The list of counters in "
        + "'CounterCollection' are : ");
    for (int i = 0; i < myNewCounterCollection.get_Count();
 i++) {
        Console.WriteLine("Counter {0} is '{1}'", 
            System.Convert.ToString(i), 
            myNewCounterCollection.get_Item(i).get_CounterName());
    }
}
else {
    Console.WriteLine("The category already exists");
}
J#
String myCategoryName;
int numberOfCounters;
Console.Write("Enter the number of counters : ");
numberOfCounters = Int32.Parse(Console.ReadLine());
CounterCreationData myCounterCreationData[] = new 
    CounterCreationData[numberOfCounters];
for (int i = 0; i < numberOfCounters; i++)
 {
    Console.Write("Enter the counter name for {0} counter
 : ",
        System.Convert.ToString(i));
    myCounterCreationData[i] = new CounterCreationData();
    myCounterCreationData[i].set_CounterName(Console.ReadLine());
}
CounterCreationDataCollection myCounterCollection = new 
    CounterCreationDataCollection(myCounterCreationData);
Console.Write("Enter the category Name:");
myCategoryName = Console.ReadLine();
// Check if the category already exists or not.
if (!(PerformanceCounterCategory.Exists(myCategoryName))) {
    CounterCreationDataCollection myNewCounterCollection = new
 
        CounterCreationDataCollection(myCounterCollection);
    PerformanceCounterCategory.Create(myCategoryName,
        "Sample Category", myNewCounterCollection);

    for (int i = 0; i < numberOfCounters; i++)
 {
        myCounter = new PerformanceCounter(myCategoryName, 
            myCounterCreationData[i].get_CounterName(), "", false);
    }
    Console.WriteLine("The list of counters in "
        + "'CounterCollection' are : ");
    for (int i = 0; i < myNewCounterCollection.get_Count();
 i++) {
        Console.WriteLine("Counter {0} is '{1}'", 
            System.Convert.ToString(i), 
            myNewCounterCollection.get_Item(i).get_CounterName());
    }
}
else {
    Console.WriteLine("The category already exists");
}
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0、1.1、1.0
参照参照
関連項目
CounterCreationDataCollection クラス
CounterCreationDataCollection メンバ
System.Diagnostics 名前空間

CounterCreationDataCollection コンストラクタ

CounterCreationDataCollection クラスの新しいインスタンスを初期化します。
オーバーロードの一覧オーバーロードの一覧

名前 説明
CounterCreationDataCollection () CounterCreationData インスタンスに関連付けずに、CounterCreationDataCollection クラスの新しいインスタンスを初期化します。
CounterCreationDataCollection (CounterCreationData[]) CounterCreationData インスタンスの配列を指定して、CounterCreationDataCollection クラスの新しいインスタンスを初期化します。
CounterCreationDataCollection (CounterCreationDataCollection) CounterCreationData インスタンスのコレクションを指定して、CounterCreationDataCollection クラスの新しいインスタンスを初期化します。
参照参照

関連項目

CounterCreationDataCollection クラス
CounterCreationDataCollection メンバ
System.Diagnostics 名前空間

CounterCreationDataCollection プロパティ


パブリック プロパティパブリック プロパティ

( プロテクト プロパティ も参照)
  名前 説明
パブリック プロパティ Capacity  CollectionBase に格納できる要素の数を取得または設定します。 ( CollectionBase から継承されます。)
パブリック プロパティ Count  CollectionBase インスタンスに格納されている要素の数を取得します。このプロパティはオーバーライドできません。 ( CollectionBase から継承されます。)
パブリック プロパティ Item CounterCreationData コレクションのインデックスを作成します。
プロテクト プロパティプロテクト プロパティ
  名前 説明
プロテクト プロパティ InnerList  CollectionBase インスタンス内の要素のリストを格納する ArrayList を取得します。 ( CollectionBase から継承されます。)
プロテクト プロパティ List  CollectionBase インスタンス内の要素のリストを格納する IList を取得します。 ( CollectionBase から継承されます。)
参照参照

関連項目

CounterCreationDataCollection クラス
System.Diagnostics 名前空間

CounterCreationDataCollection メソッド


パブリック メソッドパブリック メソッド

( プロテクト メソッド も参照)
  名前 説明
パブリック メソッド Add コレクションに CounterCreationData クラスのインスタンスを追加します。
パブリック メソッド AddRange オーバーロードされます。 コレクションに複数の CounterCreationData インスタンスを追加します。
パブリック メソッド Clear  CollectionBase インスタンスからすべてのオブジェクトを削除します。このメソッドはオーバーライドできません。 ( CollectionBase から継承されます。)
パブリック メソッド Contains CounterCreationData インスタンスがコレクションにあるかどうかを判断します。
パブリック メソッド CopyTo CounterCreationData の要素を array にコピーします。コピーは、array 内の指定したインデックス位置から開始されます。
パブリック メソッド Equals  オーバーロードされます。 2 つの Object インスタンスが等しいかどうかを判断します。 ( Object から継承されます。)
パブリック メソッド GetEnumerator  CollectionBase インスタンスを反復処理する列挙子を返します。 ( CollectionBase から継承されます。)
パブリック メソッド GetHashCode  特定の型のハッシュ関数として機能します。GetHashCode は、ハッシュ アルゴリズムや、ハッシュ テーブルのようなデータ構造での使用に適しています。 ( Object から継承されます。)
パブリック メソッド GetType  現在のインスタンスの Type を取得します。 ( Object から継承されます。)
パブリック メソッド IndexOf コレクション内での CounterCreationData のインデックスを返します。
パブリック メソッド Insert コレクション内の指定したインデックス位置に、CounterCreationData を挿入します。
パブリック メソッド ReferenceEquals  指定した複数の Object インスタンスが同一かどうかを判断します。 ( Object から継承されます。)
パブリック メソッド Remove CounterCreationData をコレクションから削除します。
パブリック メソッド RemoveAt  CollectionBase インスタンスの指定したインデックスにある要素を削除します。このメソッドはオーバーライドできません。 ( CollectionBase から継承されます。)
パブリック メソッド ToString  現在の Object を表す String を返します。 ( Object から継承されます。)
プロテクト メソッドプロテクト メソッド
  名前 説明
プロテクト メソッド Finalize  Object がガベージ コレクションにより収集される前に、その Object がリソースを解放し、その他のクリーンアップ操作を実行できるようにします。 ( Object から継承されます。)
プロテクト メソッド MemberwiseClone  現在の Object の簡易コピーを作成します。 ( Object から継承されます。)
プロテクト メソッド OnClear  CollectionBase インスタンスの内容を消去するときに、追加のカスタム プロセスを実行します。 ( CollectionBase から継承されます。)
プロテクト メソッド OnClearComplete  CollectionBase インスタンスの内容を消去した後に、追加のカスタム プロセスを実行します。 ( CollectionBase から継承されます。)
プロテクト メソッド OnInsert  CollectionBase インスタンスに新しい要素を挿入する前に、追加のカスタム プロセスを実行します。 ( CollectionBase から継承されます。)
プロテクト メソッド OnInsertComplete  CollectionBase インスタンスに新しい要素を挿入した後に、追加のカスタム プロセスを実行します。 ( CollectionBase から継承されます。)
プロテクト メソッド OnRemove  CollectionBase インスタンスから要素を削除するときに、追加のカスタム プロセスを実行します。 ( CollectionBase から継承されます。)
プロテクト メソッド OnRemoveComplete  CollectionBase インスタンスから要素を削除した後に、追加のカスタム プロセスを実行します。 ( CollectionBase から継承されます。)
プロテクト メソッド OnSet  CollectionBase インスタンスに値を設定する前に、追加のカスタム プロセスを実行します。 ( CollectionBase から継承されます。)
プロテクト メソッド OnSetComplete  CollectionBase インスタンスに値を設定した後に、追加のカスタム プロセスを実行します。 ( CollectionBase から継承されます。)
プロテクト メソッド OnValidate オーバーライドされます。 指定されたオブジェクトをチェックして、有効な CounterCreationData 型であるかどうかを決定します。
参照参照

関連項目

CounterCreationDataCollection クラス
System.Diagnostics 名前空間

CounterCreationDataCollection メンバ

CounterCreationData オブジェクトの厳密に型指定されたコレクションを提供します。

CounterCreationDataCollection データ型で公開されるメンバを以下の表に示します。


パブリック コンストラクタパブリック コンストラクタ
  名前 説明
パブリック メソッド CounterCreationDataCollection オーバーロードされます。 CounterCreationDataCollection クラスの新しいインスタンスを初期化します。
パブリック プロパティパブリック プロパティ
( プロテクト プロパティ も参照)
  名前 説明
パブリック プロパティ Capacity  CollectionBase に格納できる要素の数を取得または設定します。(CollectionBase から継承されます。)
パブリック プロパティ Count  CollectionBase インスタンスに格納されている要素の数を取得します。このプロパティはオーバーライドできません。(CollectionBase から継承されます。)
パブリック プロパティ Item CounterCreationData コレクションのインデックスを作成します。
プロテクト プロパティプロテクト プロパティ
  名前 説明
プロテクト プロパティ InnerList  CollectionBase インスタンス内の要素のリストを格納する ArrayList を取得します。(CollectionBase から継承されます。)
プロテクト プロパティ List  CollectionBase インスタンス内の要素のリストを格納する IList を取得します。(CollectionBase から継承されます。)
パブリック メソッドパブリック メソッド
( プロテクト メソッド も参照)
  名前 説明
パブリック メソッド Add コレクションに CounterCreationData クラスのインスタンスを追加します。
パブリック メソッド AddRange オーバーロードされます。 コレクションに複数の CounterCreationData インスタンスを追加します。
パブリック メソッド Clear  CollectionBase インスタンスからすべてのオブジェクトを削除します。このメソッドはオーバーライドできません。 (CollectionBase から継承されます。)
パブリック メソッド Contains CounterCreationData インスタンスがコレクションにあるかどうかを判断します。
パブリック メソッド CopyTo CounterCreationData の要素を array にコピーします。コピーは、array 内の指定したインデックス位置から開始されます。
パブリック メソッド Equals  オーバーロードされます。 2 つの Object インスタンスが等しいかどうかを判断します。 (Object から継承されます。)
パブリック メソッド GetEnumerator  CollectionBase インスタンスを反復処理する列挙子を返します。 (CollectionBase から継承されます。)
パブリック メソッド GetHashCode  特定の型のハッシュ関数として機能します。GetHashCode は、ハッシュ アルゴリズムや、ハッシュ テーブルのようなデータ構造での使用に適しています。 (Object から継承されます。)
パブリック メソッド GetType  現在のインスタンスの Type を取得します。 (Object から継承されます。)
パブリック メソッド IndexOf コレクション内での CounterCreationData のインデックスを返します。
パブリック メソッド Insert コレクション内の指定したインデックス位置に、CounterCreationData を挿入します。
パブリック メソッド ReferenceEquals  指定した複数の Object インスタンスが同一かどうかを判断します。 (Object から継承されます。)
パブリック メソッド Remove CounterCreationData をコレクションから削除します。
パブリック メソッド RemoveAt  CollectionBase インスタンスの指定したインデックスにある要素を削除します。このメソッドはオーバーライドできません。 (CollectionBase から継承されます。)
パブリック メソッド ToString  現在の Object を表す String を返します。 (Object から継承されます。)
プロテクト メソッドプロテクト メソッド
  名前 説明
プロテクト メソッド Finalize  Object がガベージ コレクションにより収集される前に、その Object がリソースを解放し、その他のクリーンアップ操作を実行できるようにします。 (Object から継承されます。)
プロテクト メソッド MemberwiseClone  現在の Object の簡易コピーを作成します。 (Object から継承されます。)
プロテクト メソッド OnClear  CollectionBase インスタンスの内容を消去するときに、追加のカスタム プロセスを実行します。 (CollectionBase から継承されます。)
プロテクト メソッド OnClearComplete  CollectionBase インスタンスの内容を消去した後に、追加のカスタム プロセスを実行します。 (CollectionBase から継承されます。)
プロテクト メソッド OnInsert  CollectionBase インスタンスに新しい要素を挿入する前に、追加のカスタム プロセスを実行します。 (CollectionBase から継承されます。)
プロテクト メソッド OnInsertComplete  CollectionBase インスタンスに新しい要素を挿入した後に、追加のカスタム プロセスを実行します。 (CollectionBase から継承されます。)
プロテクト メソッド OnRemove  CollectionBase インスタンスから要素を削除するときに、追加のカスタム プロセスを実行します。 (CollectionBase から継承されます。)
プロテクト メソッド OnRemoveComplete  CollectionBase インスタンスから要素を削除した後に、追加のカスタム プロセスを実行します。 (CollectionBase から継承されます。)
プロテクト メソッド OnSet  CollectionBase インスタンスに値を設定する前に、追加のカスタム プロセスを実行します。 (CollectionBase から継承されます。)
プロテクト メソッド OnSetComplete  CollectionBase インスタンスに値を設定した後に、追加のカスタム プロセスを実行します。 (CollectionBase から継承されます。)
プロテクト メソッド OnValidate オーバーライドされます。 指定されたオブジェクトをチェックして、有効な CounterCreationData 型であるかどうかを決定します。
参照参照

関連項目

CounterCreationDataCollection クラス
System.Diagnostics 名前空間

急上昇のことば

毒親
きょうじ
悔恨
拮抗
いささか

英和和英テキスト翻訳

英語⇒日本語日本語⇒英語

辞書ショートカット

カテゴリ一覧

全て

＋ ビジネス

＋ 業界用語

＋ コンピュータ

＋ 電車

＋ 自動車・バイク

＋ 船

＋ 工学

＋ 建築・不動産

＋ 学問

＋ 文化

＋ 生活

＋ ヘルスケア

＋ 趣味

＋ スポーツ

＋ 生物

＋ 食品

＋ 人名

＋ 方言

＋ 辞書・百科事典

すべての辞書の索引

あいうえお
かきくけこ
さしすせそ
たちつてと
なにぬねの
はひふへほ
まみむめも
やゆよ
らりるれろ
わをん
がぎぐげご
ざじずぜぞ
だぢづでど
ばびぶべぼ
ぱぴぷぺぽ
ＡＢＣＤＥ
ＦＧＨＩＪ
ＫＬＭＮＯ
ＰＱＲＳＴ
ＵＶＷＸＹ
Ｚ
１２３４５
６７８９０
記号

Weblioのサービス

「CounterCreationDataCollection」の関連用語

1
CounterCreationDataCollection.AddRange メソッド
.NET Framework クラス ライブラリ リファレンス
100% |||||

2
PerformanceCounter フィールド
.NET Framework クラス ライブラリ リファレンス
78% |||||

3
PerformanceCounterInstaller.Counters プロパティ
.NET Framework クラス ライブラリ リファレンス
76% |||||

4
CounterCreationDataCollection コンストラクタ ()
.NET Framework クラス ライブラリ リファレンス
74% |||||

5
PerformanceCounter イベント
.NET Framework クラス ライブラリ リファレンス
70% |||||

6
PerformanceCounterCategory.Create メソッド
.NET Framework クラス ライブラリ リファレンス
54% |||||

7
CounterCreationDataCollection.IndexOf メソッド
.NET Framework クラス ライブラリ リファレンス
54% |||||

8
CounterCreationDataCollection.Insert メソッド
.NET Framework クラス ライブラリ リファレンス
54% |||||

9
CounterCreationData プロパティ
.NET Framework クラス ライブラリ リファレンス
52% |||||

10
CounterCreationDataCollection.CopyTo メソッド
.NET Framework クラス ライブラリ リファレンス
52% |||||

CounterCreationDataCollectionのお隣キーワード

CorrelationManager.LogicalOperationStack プロパティ

CorrelationManager.StartLogicalOperation メソッド

CorrelationManager.StopLogicalOperation メソッド

CounterCreationData.CounterHelp プロパティ

CounterCreationData.CounterName プロパティ

CounterCreationData.CounterType プロパティ

CounterCreationDataCollection

CounterCreationDataCollection クラス

CounterCreationDataCollection コンストラクタ

CounterCreationDataCollection プロパティ

CounterCreationDataCollection メソッド

CounterCreationDataCollection メンバ

CounterCreationDataCollection.Add メソッド

検索ランキング

   

 英語⇒日本語
日本語⇒英語		    


CounterCreationDataCollectionのページの著作権

   
日本マイクロソフト株式会社日本マイクロソフト株式会社
© 2026 Microsoft.All rights reserved.

©2026 GRAS Group, Inc.RSS