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 PerformanceCounterCategory

 

Publicado: octubre de 2016

Representa un objeto de rendimiento, que define una categoría de contadores de rendimiento.

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

System.Object
  System.Diagnostics.PerformanceCounterCategory

[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	SharedState = true)]
public sealed class PerformanceCounterCategory

NombreDescripción
System_CAPS_pubmethodPerformanceCounterCategory()

Inicializa una nueva instancia de la PerformanceCounterCategory clase deja el CategoryName propiedad vacía y establece la MachineName propiedad en el equipo local.

System_CAPS_pubmethodPerformanceCounterCategory(String)

Inicializa una nueva instancia de la PerformanceCounterCategory clase establece la CategoryName propiedad en el valor especificado y establece la MachineName propiedad en el equipo local.

System_CAPS_pubmethodPerformanceCounterCategory(String, String)

Inicializa una nueva instancia de la PerformanceCounterCategory clase y se establece el CategoryName y MachineName Propiedades en los valores especificados.

NombreDescripción
System_CAPS_pubpropertyCategoryHelp

Obtiene el texto de Ayuda de la categoría.

System_CAPS_pubpropertyCategoryName

Obtiene o establece el nombre del objeto de rendimiento que define esta categoría.

System_CAPS_pubpropertyCategoryType

Obtiene el tipo de categoría de contador de rendimiento.

System_CAPS_pubpropertyMachineName

Obtiene o establece el nombre del equipo en el que existe esta categoría.

NombreDescripción
System_CAPS_pubmethodCounterExists(String)

Determina si el contador especificado está registrado en esta categoría, que se indica mediante el CategoryName y MachineName Propiedades.

System_CAPS_pubmethodSystem_CAPS_staticCounterExists(String, String)

Determina si el contador especificado está registrado en la categoría especificada en el equipo local.

System_CAPS_pubmethodSystem_CAPS_staticCounterExists(String, String, String)

Determina si el contador especificado está registrado en la categoría especificada en un equipo remoto.

System_CAPS_pubmethodSystem_CAPS_staticCreate(String, String, CounterCreationDataCollection)

Obsoleto. Registra la categoría de contador de rendimiento personalizada que contiene los contadores especificados en el equipo local.

System_CAPS_pubmethodSystem_CAPS_staticCreate(String, String, PerformanceCounterCategoryType, CounterCreationDataCollection)

Registra la categoría de contador de rendimiento personalizada que contiene los contadores especificados en el equipo local.

System_CAPS_pubmethodSystem_CAPS_staticCreate(String, String, PerformanceCounterCategoryType, String, String)

Registra la categoría de contador de rendimiento personalizado que contiene un solo contador de tipo NumberOfItems32 en el equipo local.

System_CAPS_pubmethodSystem_CAPS_staticCreate(String, String, String, String)

Obsoleto. Registra una categoría de contador de rendimiento personalizada que contiene un solo contador de tipo NumberOfItems32 en el equipo local.

System_CAPS_pubmethodSystem_CAPS_staticDelete(String)

Quita la categoría y sus contadores asociados desde el equipo local.

System_CAPS_pubmethodEquals(Object)

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

System_CAPS_pubmethodSystem_CAPS_staticExists(String)

Determina si la categoría está registrada en el equipo local.

System_CAPS_pubmethodSystem_CAPS_staticExists(String, String)

Determina si la categoría está registrada en el equipo especificado.

System_CAPS_pubmethodSystem_CAPS_staticGetCategories()

Recupera una lista de las categorías de contador de rendimiento que están registrados en el equipo local.

System_CAPS_pubmethodSystem_CAPS_staticGetCategories(String)

Recupera una lista de las categorías de contador de rendimiento que están registrados en el equipo especificado.

System_CAPS_pubmethodGetCounters()

Recupera una lista de los contadores de una categoría de contador de rendimiento que contiene exactamente una instancia.

System_CAPS_pubmethodGetCounters(String)

Recupera una lista de los contadores de una categoría de contador de rendimiento que contiene una o más instancias.

System_CAPS_pubmethodGetHashCode()

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

System_CAPS_pubmethodGetInstanceNames()

Recupera la lista de instancias de objeto de rendimiento asociados a esta categoría.

System_CAPS_pubmethodGetType()

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

System_CAPS_pubmethodInstanceExists(String)

Determina si la instancia de objeto de rendimiento especificada existe en la categoría identificado por este PerformanceCounterCategory del objeto CategoryName propiedad.

System_CAPS_pubmethodSystem_CAPS_staticInstanceExists(String, String)

Determina si una categoría especificada en el equipo local contiene la instancia de objeto de rendimiento especificada.

System_CAPS_pubmethodSystem_CAPS_staticInstanceExists(String, String, String)

Determina si una categoría especificada en un equipo especificado contiene la instancia de objeto de rendimiento especificada.

System_CAPS_pubmethodReadCategory()

Lee todos los contadores y el rendimiento objeto instancia datos que está asociados a esta categoría de contador de rendimiento.

System_CAPS_pubmethodToString()

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

System_CAPS_importantImportante

Creación o eliminación de un contador de rendimiento requiere la sincronización del código subyacente utilizando una exclusión mutua con nombre. Si una aplicación con muchos privilegios bloquea la exclusión mutua con nombre, los intentos de crear o eliminar un contador de rendimiento hace que la aplicación deje de responder hasta que se libere el bloqueo. Para evitar este problema, no conceda nunca UnmanagedCode permiso al código no es de confianza. Además, UnmanagedCode permiso potencialmente permite omitir otros permisos y sólo debe concederse a código de plena confianza.

El PerformanceCounterCategory la instancia CategoryName propiedad se muestra en el campo de objeto de rendimiento del cuadro de diálogo Agregar contador de la aplicación Visor de rendimiento.

La PerformanceCounterCategory clase proporciona varios métodos para interactuar con los contadores y categorías en el equipo. El Create métodos le permiten definir categorías personalizadas. El Delete método proporciona un medio para quitar categorías del equipo. El GetCategories método le permite ver la lista de categorías, mientras ReadCategory recupera todos los datos de contadores e instancias asociados a una única categoría.

Un contador de rendimiento publica los datos de rendimiento sobre una aplicación. Categorías incluyen los componentes físicos (como procesadores, discos y memoria) y objetos del sistema (como procesos y subprocesos). Contadores del sistema que están relacionados con el mismo objeto de rendimiento se agrupan en una categoría que indica su enfoque común. Cuando se crea una instancia de la PerformanceCounter (clase), primero debe indicarse la categoría con la que interactuará el componente y, a continuación, elija un contador de dicha categoría.

Por ejemplo, una categoría de contador de Windows es la categoría de memoria. Contadores del sistema de esta categoría de seguimiento de datos de la memoria como el número de bytes disponibles y el número de bytes almacenados en caché. Si desea trabajar con los bytes almacenados en caché en su aplicación, debe crear una instancia de la PerformanceCounter componente, conéctese a la categoría de memoria y, a continuación, elegir el contador adecuado (en este caso, Cached Bytes) de esa categoría.

Aunque el sistema tiene muchas más categorías de contador disponibles, las categorías que probablemente interactuará con más frecuencia son las categorías de caché, memoria, objetos, DiscoFísico, proceso, procesador, servidor, sistema y subproceso.

System_CAPS_importantImportante

El RemoveInstance método en la PerformanceCounter clase liberará el contador y, si se selecciona la opción reutilizar para esa categoría, se volverá a la instancia del contador. Esto podría causar una condición de carrera si otro proceso o incluso otra parte del código está intentando escribir en la instancia del contador.

System_CAPS_noteNota

Se recomienda encarecidamente que se crean nuevas categorías de contador de rendimiento durante la instalación de la aplicación, no durante la ejecución de la aplicación. Esto da tiempo para el sistema operativo actualizar su lista de categorías de contador de rendimiento registrados. Si no se ha actualizado la lista, se producirá un error al intentar utilizar la categoría.

System_CAPS_noteNota

Categorías de contador de rendimiento instaladas con el .NET Framework 2.0 usar memoria compartida independiente, y cada categoría de contador de rendimiento tiene su propia memoria. Puede especificar el tamaño de memoria compartida independiente creando un DWORD denominado FileMappingSize en la clave del registro HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\< nombre de la categoría >\Performance. El valor de FileMappingSize se establece en el tamaño de memoria compartida de la categoría. El tamaño predeterminado es el valor decimal 131072. Si el valor de FileMappingSize no está presente, el fileMappingSize valor del atributo para el performanceCounters se utiliza el elemento especificado en el archivo Machine.config, provocando una sobrecarga adicional para el procesamiento del archivo de configuración. Puede conseguir una mejora del rendimiento de inicio de la aplicación estableciendo el tamaño de asignación del archivo en el registro. Para obtener más información sobre el tamaño de asignación de archivos, consulte <performanceCounters> (Elemento).

En el ejemplo de código siguiente se determina si un PerformanceCounter y su PerformanceCounterCategory existe en el equipo local o en otro equipo. Si estos objetos no existen en el equipo local, el ejemplo opcionalmente crea. Usa el Exists método para determinar si el PerformanceCounterCategory existe. Si el PerformanceCounterCategory no existe y se especifica ningún nombre de contador o si el equipo es un equipo remoto, en el ejemplo se cierra.

Si un PerformanceCounter se proporciona el nombre, el ejemplo utiliza la CounterExists (método) y muestra el resultado al usuario. Si el PerformanceCounter no existe, el usuario puede eliminar y volver a crear la PerformanceCounterCategory con la nueva PerformanceCounter. Si lo hace, se elimina la categoría mediante el Delete método.

Si se solicita, el ejemplo crea ahora el nuevo PerformanceCounterCategory y PerformanceCounter mediante el Create método. Si se especifica un nombre de instancia, el ejemplo utiliza la InstanceExists (método) y muestra el resultado.

using System;
using System.Diagnostics;
using Microsoft.VisualBasic;

class PerfCounterCatCreateExistMod
{

    public static void Main(string[] args)
    {
        string categoryName = "";
        string counterName = "";
        string instanceName = "";
        string machineName = "";
        string categoryHelp = "";
        string counterHelp = "";
        bool objectExists = false;
        PerformanceCounterCategory pcc;
        bool createCategory = false;

        // Copy the supplied arguments into the local variables.
        try
        {
            categoryName = args[0];
            counterName = args[1];
            instanceName = args[2];
            machineName = args[3]=="."? "": args[3];
            categoryHelp = args[4];
            counterHelp = args[5];
        }
        catch(Exception ex)
        {
            // Ignore the exception from non-supplied arguments.
        }

        // Verify that the category name is not blank.
        if (categoryName.Length==0)
        {
            Console.WriteLine("Category name cannot be blank.");
            return;
        }

        // Check whether the specified category exists.
        if (machineName.Length==0)
        {
            objectExists = PerformanceCounterCategory.Exists(categoryName);

        }
        else
        {
            // Handle the exception that is thrown if the computer 
            // cannot be found.
            try
            {
                objectExists = PerformanceCounterCategory.Exists(categoryName, machineName);
            }
            catch(Exception ex)
            {
                Console.WriteLine("Error checking for existence of " +
                    "category \"{0}\" on computer \"{1}\":"+"\n" +ex.Message, categoryName, machineName);
                return;
            }
        }

        // Tell the user whether the specified category exists.
        Console.WriteLine("Category \"{0}\" "+ (objectExists? "exists on ": "does not exist on ")+
            (machineName.Length>0? "computer \"{1}\".": "this computer."), categoryName, machineName);

        // If no counter name is given, the program cannot continue.
        if (counterName.Length==0)
        {
            return;
        }

        // A category can only be created on the local computer.
        if (!objectExists)
        {
            if (machineName.Length>0)
            {
                return;
            }
            else
            {
                createCategory = true;
            }
        }
        else
        {
            // Check whether the specified counter exists.
            if (machineName.Length==0)
            {
                objectExists = PerformanceCounterCategory.CounterExists(counterName, categoryName);
            }
            else
            {
                objectExists = PerformanceCounterCategory.CounterExists(counterName, categoryName, machineName);
            }

            // Tell the user whether the counter exists.
            Console.WriteLine("Counter \"{0}\" "+(objectExists? "exists": "does not exist")+
                " in category \"{1}\" on "+(machineName.Length>0? "computer \"{2}\".": "this computer."), 
                counterName, categoryName, machineName);

            // If the counter does not exist, consider creating it.
            if (!objectExists)

                // If this is a remote computer, 
                // exit because the category cannot be created.
            {
                if (machineName.Length>0)
                {
                    return;
                }
                else
                {
                    // Ask whether the user wants to recreate the category.
                    Console.Write("Do you want to delete and recreate " +
                        "category \"{0}\" with your new counter? [Y/N]: ", categoryName);
                    string userReply = Console.ReadLine();

                    // If yes, delete the category so it can be recreated later.
                    if (userReply.Trim().ToUpper()=="Y")
                    {
                        PerformanceCounterCategory.Delete(categoryName);
                        createCategory = true;
                    }
                    else
                    {
                        return;
                    }
                }
            }
        }

        // Create the category if it was deleted or it never existed.
        if (createCategory)
        {
            pcc = PerformanceCounterCategory.Create(categoryName, categoryHelp, counterName, counterHelp);

            Console.WriteLine("Category \"{0}\" with counter \"{1}\" created.", pcc.CategoryName, counterName);

        }
        else if(instanceName.Length>0)
        {
            if (machineName.Length==0)
            {
                objectExists = PerformanceCounterCategory.InstanceExists(instanceName, categoryName);
            }
            else
            {
                objectExists = PerformanceCounterCategory.InstanceExists(instanceName, categoryName, machineName);
            }

            // Tell the user whether the instance exists.
            Console.WriteLine("Instance \"{0}\" "+(objectExists? "exists": "does not exist")+
                " in category \"{1}\" on " + (machineName.Length>0? "computer \"{2}\".": "this computer."), 
                instanceName, categoryName, machineName);
        }
    }
}

.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: