Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase CounterCreationDataCollection

 

Proporciona una colección fuertemente tipada de objetos CounterCreationData.

Espacio de nombres:   System.Diagnostics
Ensamblado:  System (en System.dll)

System.Object
  System.Collections.CollectionBase
    System.Diagnostics.CounterCreationDataCollection

[SerializableAttribute]
public class CounterCreationDataCollection : CollectionBase

NombreDescripción
System_CAPS_pubmethodCounterCreationDataCollection()

Inicializa una nueva instancia de la CounterCreationDataCollection (clase), sin ningún asociado CounterCreationData instancias.

System_CAPS_pubmethodCounterCreationDataCollection(CounterCreationData[])

Inicializa una nueva instancia de la CounterCreationDataCollection clase utilizando la matriz especificada de CounterCreationData instancias.

System_CAPS_pubmethodCounterCreationDataCollection(CounterCreationDataCollection)

Inicializa una nueva instancia de la CounterCreationDataCollection clase utilizando la colección especificada de CounterCreationData instancias.

NombreDescripción
System_CAPS_pubpropertyCapacity

Obtiene o establece el número de elementos que puede contener CollectionBase.(Heredado de CollectionBase).

System_CAPS_pubpropertyCount

Obtiene el número de elementos incluidos en la instancia de CollectionBase. Esta propiedad no se puede invalidar.(Heredado de CollectionBase).

System_CAPS_protpropertyInnerList

Obtiene un ArrayList que contiene la lista de elementos de la CollectionBase instancia.(Heredado de CollectionBase).

System_CAPS_pubpropertyItem[Int32]

Índices del CounterCreationData colección.

System_CAPS_protpropertyList

Obtiene un IList que contiene la lista de elementos de la CollectionBase instancia.(Heredado de CollectionBase).

NombreDescripción
System_CAPS_pubmethodAdd(CounterCreationData)

Agrega una instancia de la CounterCreationData clase a la colección.

System_CAPS_pubmethodAddRange(CounterCreationData[])

Agrega la matriz especificada de CounterCreationData instancias a la colección.

System_CAPS_pubmethodAddRange(CounterCreationDataCollection)

Agrega la colección especificada de CounterCreationData instancias a la colección.

System_CAPS_pubmethodClear()

Quita todos los objetos de la CollectionBase instancia. Este método no se puede invalidar.(Heredado de CollectionBase).

System_CAPS_pubmethodContains(CounterCreationData)

Determina si un CounterCreationData instancia existe en la colección.

System_CAPS_pubmethodCopyTo(CounterCreationData[], Int32)

Copia los elementos de la CounterCreationData en una matriz, comenzando en el índice especificado de la matriz.

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object).

System_CAPS_pubmethodGetEnumerator()

Devuelve un enumerador que recorre en iteración el CollectionBase instancia.(Heredado de CollectionBase).

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodIndexOf(CounterCreationData)

Devuelve el índice de un CounterCreationData objeto de la colección.

System_CAPS_pubmethodInsert(Int32, CounterCreationData)

Inserta un CounterCreationData objeto en la colección en el índice especificado.

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_protmethodOnClear()

Realiza procesos personalizados adicionales al borrar el contenido de la CollectionBase instancia.(Heredado de CollectionBase).

System_CAPS_protmethodOnClearComplete()

Realiza procesos personalizados adicionales después de borrar el contenido de la instancia de CollectionBase.(Heredado de CollectionBase).

System_CAPS_protmethodOnInsert(Int32, Object)

Realiza procesos personalizados adicionales antes de insertar un nuevo elemento en la instancia de CollectionBase.(Heredado de CollectionBase).

System_CAPS_protmethodOnInsertComplete(Int32, Object)

Realiza procesos personalizados adicionales después de insertar un nuevo elemento en la instancia de CollectionBase.(Heredado de CollectionBase).

System_CAPS_protmethodOnRemove(Int32, Object)

Realiza procesos personalizados adicionales al quitar un elemento de la CollectionBase instancia.(Heredado de CollectionBase).

System_CAPS_protmethodOnRemoveComplete(Int32, Object)

Realiza procesos personalizados adicionales después de quitar un elemento de la instancia de CollectionBase.(Heredado de CollectionBase).

System_CAPS_protmethodOnSet(Int32, Object, Object)

Realiza procesos personalizados adicionales antes de establecer un valor en la instancia de CollectionBase.(Heredado de CollectionBase).

System_CAPS_protmethodOnSetComplete(Int32, Object, Object)

Realiza procesos personalizados adicionales después de establecer un valor en la instancia de CollectionBase.(Heredado de CollectionBase).

System_CAPS_protmethodOnValidate(Object)

Comprueba el objeto especificado para determinar si es válido CounterCreationData tipo.(Invalida CollectionBase.OnValidate(Object)).

System_CAPS_pubmethodRemove(CounterCreationData)

Quita un CounterCreationData objeto de la colección.

System_CAPS_pubmethodRemoveAt(Int32)

Quita el elemento en el índice especificado de la CollectionBase instancia. Este método no es reemplazable.(Heredado de CollectionBase).

System_CAPS_pubmethodToString()

Retorna una cadena que representa al objeto actual. (Heredado de Object).

NombreDescripción
System_CAPS_pubinterfaceSystem_CAPS_privmethodICollection.CopyTo(Array, Int32)

Copia la totalidad de CollectionBase en una matriz Array unidimensional compatible, comenzando en el índice especificado de la matriz de destino.(Heredado de CollectionBase).

System_CAPS_pubinterfaceSystem_CAPS_privmethodIList.Add(Object)

Agrega un objeto al final de CollectionBase.(Heredado de CollectionBase).

System_CAPS_pubinterfaceSystem_CAPS_privmethodIList.Contains(Object)

Determina si CollectionBase contiene un elemento específico.(Heredado de CollectionBase).

System_CAPS_pubinterfaceSystem_CAPS_privmethodIList.IndexOf(Object)

Busca el objeto Object especificado y devuelve el índice de base cero de la primera aparición en toda la colección CollectionBase.(Heredado de CollectionBase).

System_CAPS_pubinterfaceSystem_CAPS_privmethodIList.Insert(Int32, Object)

Inserta un elemento en CollectionBase, en el índice especificado.(Heredado de CollectionBase).

System_CAPS_pubinterfaceSystem_CAPS_privmethodIList.Remove(Object)

Quita la primera aparición de un objeto específico de la interfaz CollectionBase.(Heredado de CollectionBase).

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection.IsSynchronized

Obtiene un valor que indica si el acceso a la interfaz CollectionBase está sincronizado (es seguro para subprocesos).(Heredado de CollectionBase).

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection.SyncRoot

Obtiene un objeto que se puede usar para sincronizar el acceso a CollectionBase.(Heredado de CollectionBase).

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIList.IsFixedSize

Obtiene un valor que indica si la interfaz CollectionBase tiene un tamaño fijo.(Heredado de CollectionBase).

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIList.IsReadOnly

Obtiene un valor que indica si CollectionBase es de solo lectura.(Heredado de CollectionBase).

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIList.Item[Int32]

Obtiene o establece el elemento en el índice especificado.(Heredado de CollectionBase).

NombreDescripción
System_CAPS_pubmethodAsParallel()

Sobrecargado. Habilita la paralelización de una consulta.(Definido por ParallelEnumerable).

System_CAPS_pubmethodAsQueryable()

Sobrecargado. Convierte un IEnumerable para un IQueryable.(Definido por Queryable).

System_CAPS_pubmethodCast<TResult>()

Convierte los elementos de un IEnumerable al tipo especificado.(Definido por Enumerable).

System_CAPS_pubmethodOfType<TResult>()

Filtra los elementos de un IEnumerable basado en un tipo especificado.(Definido por Enumerable).

En el siguiente ejemplo se muestra cómo utilizar la clase CounterCreationDataCollection. El ejemplo crea una nueva instancia de la clase y utiliza varios métodos para agregar instrucciones a la colección, devolver su índice y agregar o quitar atributos en un punto de índice concreto.


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("++++++++++++++++++++++");
    }
}

.NET Framework
Disponible desde 1.1

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: