¿Le resultó útil esta página?
Sus comentarios sobre este contenido son muy importantes. Háganos saber su opinión.
¿Tiene comentarios adicionales?
Caracteres restantes: 1500
Exportar (0) Imprimir
Expandir todo

PerformanceCounterCategory (Clase)

Actualización: noviembre 2007

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

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

[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	SharedState = true)]
public sealed class PerformanceCounterCategory
/** @attribute HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, SharedState = true) */
public final class PerformanceCounterCategory
public final class PerformanceCounterCategory

c0wcx8y7.alert_note(es-es,VS.90).gifNota:

El atributo HostProtectionAttribute aplicado a este tipo o miembro tiene el siguiente valor de la 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 de SQL Server y atributos de protección del host.

c0wcx8y7.alert_caution(es-es,VS.90).gifNota importante:

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é de 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.

c0wcx8y7.alert_caution(es-es,VS.90).gifNota importante:

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 anticipación si otro proceso o incluso otra parte del código está intentando escribir en la instancia del contador.

c0wcx8y7.alert_note(es-es,VS.90).gifNota:

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.

c0wcx8y7.alert_note(es-es,VS.90).gifNota:

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

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);
        }
    }
}


System.Object
  System.Diagnostics.PerformanceCounterCategory

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.

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

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

.NET Framework

Compatible con: 3.5, 3.0, 2.0, 1.1, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft