Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

PerformanceCounterCategory (Clase)

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

System.Object
  System.Diagnostics.PerformanceCounterCategory

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

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

El tipo PerformanceCounterCategory expone los siguientes miembros.

  NombreDescripción
Método públicoPerformanceCounterCategory()Inicializa una nueva instancia de la clase PerformanceCounterCategory, deja la propiedad CategoryName vacía y establece la propiedad MachineName en el equipo local.
Método públicoPerformanceCounterCategory(String)Inicializa una nueva instancia de la clase PerformanceCounterCategory, establece la propiedad CategoryName en el valor especificado y establece la propiedad MachineName en el equipo local.
Método públicoPerformanceCounterCategory(String, String)Inicializa una nueva instancia de la clase PerformanceCounterCategory y establece las propiedades CategoryName y MachineName en los valores especificados.
Arriba

  NombreDescripción
Propiedad públicaCategoryHelpObtiene el texto de ayuda de la categoría.
Propiedad públicaCategoryNameObtiene o establece el nombre del objeto de rendimiento que define esta categoría.
Propiedad públicaCategoryTypeObtiene el tipo de categoría de contador de rendimiento.
Propiedad públicaMachineNameObtiene o establece el nombre del equipo en el que reside esta categoría.
Arriba

  NombreDescripción
Método públicoCounterExists(String)Determina si el contador especificado está registrado en esta categoría; esta información se indica mediante las propiedades CategoryName y MachineName.
Método públicoMiembro estáticoCounterExists(String, String)Determina si el contador especificado está registrado en la categoría especificada del equipo local.
Método públicoMiembro estáticoCounterExists(String, String, String)Determina si el contador especificado está registrado en la categoría especificada de un equipo remoto.
Método públicoMiembro estáticoCreate(String, String, CounterCreationDataCollection) Obsoleta. Registra la categoría de contador de rendimiento personalizada que contiene los contadores especificados en el equipo local.
Método públicoMiembro estáticoCreate(String, String, PerformanceCounterCategoryType, CounterCreationDataCollection)Registra la categoría de contador de rendimiento personalizada que contiene los contadores especificados en el equipo local.
Método públicoMiembro estáticoCreate(String, String, String, String) Obsoleta. Registra una categoría de contador de rendimiento personalizada que contiene un solo contador de tipo NumberOfItems32 en el equipo local.
Método públicoMiembro estáticoCreate(String, String, PerformanceCounterCategoryType, String, String)Registra la categoría de contador de rendimiento personalizada que contiene un solo contador de tipo NumberOfItems32 en el equipo local.
Método públicoMiembro estáticoDeleteQuita la categoría y los contadores asociados del equipo local.
Método públicoEquals(Object)Determina si el objeto especificado es igual al objeto actual. (Se hereda de Object).
Método públicoMiembro estáticoExists(String)Determina si la categoría está registrada en el equipo local.
Método públicoMiembro estáticoExists(String, String)Determina si la categoría está registrada en el equipo especificado.
Método públicoMiembro estáticoGetCategories()Recupera una lista de las categorías de contador de rendimiento registradas en el equipo local.
Método públicoMiembro estáticoGetCategories(String)Recupera una lista de las categorías de contador de rendimiento registradas en el equipo especificado.
Método públicoGetCounters()Recupera una lista de los contadores de una categoría de contador de rendimiento que contiene exactamente una instancia.
Método públicoGetCounters(String)Recupera una lista de los contadores de una categoría de contador de rendimiento que contiene una o más instancias.
Método públicoGetHashCode Sirve como una función hash para un tipo en particular. (Se hereda de Object).
Método públicoGetInstanceNamesRecupera la lista de instancias de objetos de rendimiento asociados a esta categoría.
Método públicoGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoInstanceExists(String)Determina si la instancia de objeto de rendimiento especificada existe en la categoría identificada por la propiedad CategoryName de este objeto PerformanceCounterCategory.
Método públicoMiembro estáticoInstanceExists(String, String)Determina si una categoría especificada en el equipo local contiene la instancia de objeto de rendimiento especificada.
Método públicoMiembro estáticoInstanceExists(String, String, String)Determina si una categoría especificada en un equipo especificado contiene la instancia de objeto de rendimiento especificada.
Método públicoReadCategoryLee todos los datos sobre el contador y la instancia de objeto de rendimiento asociados a esta categoría de contador de rendimiento.
Método públicoToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Arriba

Nota importanteImportante

La 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 que cuenta con muchos privilegios bloquea la exclusión mutua con nombre, los intentos de crear o eliminar un contador de rendimiento hará que la aplicación deje de responder hasta que desaparezca el bloqueo. Para evitar este problema, no conceda nunca el permiso UnmanagedCode a código que no sea de confianza. Además, el permiso UnmanagedCode permite potencialmente omitir otros permisos y sólo se debería conceder a código de gran confianza.

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

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

Un contador de rendimiento publica los datos de rendimiento relativos a una aplicación. Entre las categorías se incluyen los componentes físicos (como procesadores, discos y memoria) y los objetos del sistema (como procesos y subprocesos). Los 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 clase PerformanceCounter, primero se indica la categoría con la que interactuará el componente y después se elige un contador de dicha categoría.

Por ejemplo, una de las categorías de contadores de Windows es la categoría Memory. Los contadores del sistema de esta categoría hacen un seguimiento de los datos de memoria, por ejemplo, el número de bytes disponibles y el número de bytes almacenados en caché. Por ejemplo, si desea trabajar con los bytes almacenados en caché en la aplicación, debe crear una instancia del componente PerformanceCounter, conectarla a la categoría Memory y después elegir el contador adecuado (en este caso, Cached Bytes) de esa categoría.

Aunque en el sistema hay muchas más categorías de contador disponibles, lo más probable es que las categorías con las que más interactúe sean Cache, Memory, Objects, PhysicalDisk, Process, Processor, Server, System y Thread.

Nota importanteImportante

El método RemoveInstance en la clase PerformanceCounter liberará el contador y, si está seleccionada la opción Volver a usar para esa categoría, se volverá a usar 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.

NotaNota

Se recomienda crear nuevas categorías de contador de rendimiento durante la instalación de la aplicación y no durante la ejecución de la misma. De este modo, el sistema operativo dispondrá de tiempo para actualizar la lista de categorías registradas de contador de rendimiento. Si la lista no se ha actualizado, se producirá un error al intentar utilizar la categoría.

NotaNota

Las categorías de contador de rendimiento instaladas con .NET Framework 2.0 utilizan memoria compartida independiente, y cada categoría de contador de rendimiento tiene su propia memoria. Se puede especificar el tamaño de la memoria compartida independiente creando un DWORD denominado FileMappingSize en la clave del Registro HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<nombre de 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, se utiliza el valor del atributo fileMappingSize para el elemento performanceCounters especificado en el archivo Machine.config, lo que provoca una sobrecarga adicional en el procesamiento del archivo de configuración. Puede apreciar una mejora del rendimiento en el inicio de la aplicación estableciendo el tamaño de asignación de archivos en el Registro. Para obtener más información sobre el tamaño de asignación de archivos, vea <performanceCounters> (Elemento).

NotaNota

El atributo HostProtectionAttribute aplicado a este tipo o miembro tiene el siguiente valor de propiedad Resources: Synchronization | SharedState. El atributo HostProtectionAttribute no afecta a las aplicaciones de escritorio (que normalmente se inician haciendo doble clic en un icono, escribiendo un comando o introduciendo una dirección URL en el explorador). Para obtener más información, vea la clase HostProtectionAttribute o Programación en SQL Server y atributos de protección de host.

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

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

Si se solicita, se crea ahora en el ejemplo la nueva PerformanceCounterCategory y el PerformanceCounter mediante el método Create. Si hay un nombre de instancia especificado, se utiliza en el ejemplo el método InstanceExists y se 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

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft