PerformanceCounterCategory Clase

Definición

Espacio de nombres:

System.Diagnostics

Ensamblado:

System.Diagnostics.PerformanceCounter.dll

Paquete:

System.Diagnostics.PerformanceCounter v8.0.0

Source:

PerformanceCounterCategory.cs

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

public ref class PerformanceCounterCategory sealed

public sealed class PerformanceCounterCategory

type PerformanceCounterCategory = class

Public NotInheritable Class PerformanceCounterCategory

Herencia

Object

PerformanceCounterCategory

Ejemplos

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

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

Si se solicita, el ejemplo ahora crea el nuevo PerformanceCounterCategory y PerformanceCounter usa el Create método . Si se especifica un nombre de instancia, en el ejemplo se usa el InstanceExists método 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);
        }
    }
}

Imports System.Diagnostics

Module PerfCounterCatCreateExistMod

    Sub Main(ByVal args() As String)
        Dim categoryName As String = ""
        Dim counterName As String = ""
        Dim instanceName As String = ""
        Dim machineName As String = ""
        Dim categoryHelp As String = ""
        Dim counterHelp As String = ""
        Dim objectExists As Boolean = False
        Dim pcc As PerformanceCounterCategory
        Dim createCategory As Boolean = False

        ' Copy the supplied arguments into the local variables.
        Try
            categoryName = args(0)
            counterName = args(1)
            instanceName = args(2)
            machineName = IIf(args(3) = ".", "", args(3))
            categoryHelp = args(4)
            counterHelp = args(5)
        Catch ex As Exception
            ' Ignore the exception from non-supplied arguments.
        End Try

        ' Verify that the category name is not blank.
        If categoryName.Length = 0 Then
            Console.WriteLine("Category name cannot be blank.")
            Return
        End If

        ' Check whether the specified category exists.
        If machineName.Length = 0 Then
            objectExists = _
                PerformanceCounterCategory.Exists(categoryName)

        Else
            ' Handle the exception that is thrown if the computer 
            ' cannot be found.
            Try
                objectExists = PerformanceCounterCategory.Exists( _
                    categoryName, machineName)
            Catch ex As Exception
                Console.WriteLine("Error checking for existence of " & _
                    "category ""{0}"" on computer ""{1}"":" & vbCrLf & _
                    ex.Message, categoryName, machineName)
                Return
            End Try
        End If

        ' Tell the user whether the specified category exists.
        Console.WriteLine("Category ""{0}"" " & _
            IIf(objectExists, "exists on ", "does not exist on ") & _
            IIf(machineName.Length > 0, _
                "computer ""{1}"".", "this computer."), _
            categoryName, machineName)

        ' If no counter name is given, the program cannot continue.
        If counterName.Length = 0 Then
            Return
        End If

        ' A category can only be created on the local computer.
        If Not objectExists Then
            If machineName.Length > 0 Then
                Return
            Else
                createCategory = True
            End If
        Else
            ' Check whether the specified counter exists.
            If machineName.Length = 0 Then
                objectExists = PerformanceCounterCategory.CounterExists( _
                    counterName, categoryName)
            Else
                objectExists = PerformanceCounterCategory.CounterExists( _
                    counterName, categoryName, machineName)
            End If

            ' Tell the user whether the counter exists.
            Console.WriteLine("Counter ""{0}"" " & _
                IIf(objectExists, "exists", "does not exist") & _
                " in category ""{1}"" on " & _
                IIf(machineName.Length > 0, _
                    "computer ""{2}"".", "this computer."), _
                counterName, categoryName, machineName)

            ' If the counter does not exist, consider creating it.
            If Not objectExists Then

                ' If this is a remote computer, 
                ' exit because the category cannot be created.
                If machineName.Length > 0 Then
                    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)
                    Dim userReply As String = Console.ReadLine()

                    ' If yes, delete the category so it can be recreated later.
                    If userReply.Trim.ToUpper.Chars(0) = "Y" Then
                        PerformanceCounterCategory.Delete(categoryName)
                        createCategory = True
                    Else
                        Return
                    End If
                End If
            End If
        End If

        ' Create the category if it was deleted or it never existed.
        If createCategory Then
            pcc = PerformanceCounterCategory.Create( _
                categoryName, categoryHelp, counterName, counterHelp)

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

        ElseIf instanceName.Length > 0 Then

            ' If an instance name was given, check whether it exists.
            If machineName.Length = 0 Then
                objectExists = PerformanceCounterCategory.InstanceExists( _
                    instanceName, categoryName)
            Else
                objectExists = PerformanceCounterCategory.InstanceExists( _
                    instanceName, categoryName, machineName)
            End If

            ' Tell the user whether the instance exists.
            Console.WriteLine("Instance ""{0}"" " & _
                IIf(objectExists, "exists", "does not exist") & _
                " in category ""{1}"" on " & _
                IIf(machineName.Length > 0, _
                    "computer ""{2}"".", "this computer."), _
                instanceName, categoryName, machineName)
        End If
    End Sub
End Module

Comentarios

Importante

La creación o eliminación de un contador de rendimiento requiere la sincronización del código subyacente mediante una exclusión mutua con nombre. Si una aplicación con privilegios elevados bloquea la exclusión mutua con nombre, intenta 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, nunca conceda UnmanagedCode permiso a código que no es de confianza. Además, UnmanagedCode el permiso permite que se omitan otros permisos y solo se debe conceder a código de alta confianza.

La PerformanceCounterCategory propiedad de CategoryName la instancia se muestra en el campo 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 contadores y categorías en el equipo. Los Create métodos permiten definir categorías personalizadas. El Delete método proporciona una manera de quitar categorías del equipo. El GetCategories método permite ver la lista de categorías, mientras ReadCategory recupera todos los datos de contador e instancia asociados a una sola categoría.

Un contador de rendimiento publica datos de rendimiento sobre una aplicación. Las categorías incluyen componentes físicos (como procesadores, discos y memoria) y objetos del sistema (como procesos y subprocesos). Los contadores del sistema relacionados con el mismo objeto de rendimiento se agrupan en una categoría que indica su enfoque común. Al crear una instancia de la PerformanceCounter clase , primero se indica la categoría con la que interactuará el componente y, a continuación, se elige un contador de esa categoría.

Por ejemplo, una categoría de contador de Windows es la categoría Memoria. Los contadores del sistema de esta categoría realizan un seguimiento de los datos de 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 la aplicación, debe crear una instancia del PerformanceCounter componente, conectarla a la categoría Memoria y, a continuación, elegir el contador adecuado (en este caso, Bytes almacenados en caché) de esa categoría.

Aunque el sistema pone a disposición muchas más categorías de contadores, las categorías con las que probablemente interactúe con más frecuencia son las categorías Caché, Memoria, Objetos, Disco físico, Proceso, Procesador, Servidor, Sistema y Subproceso.

Importante

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

Nota

Se recomienda encarecidamente crear nuevas categorías de contadores de rendimiento durante la instalación de la aplicación, no durante la ejecución de la aplicación. Esto permite que el sistema operativo actualice su lista de categorías de contadores de rendimiento registrados. Si no se ha actualizado la lista, se producirá un error al intentar usar la categoría.

Nota

Las categorías de contadores de rendimiento instaladas con .NET Framework 2.0 usan memoria compartida independiente, con cada categoría de contador de rendimiento con su propia memoria. 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\Rendimiento. El valor FileMappingSize se establece en el tamaño de memoria compartida de la categoría. El tamaño predeterminado es 131072 decimal. Si el valor FileMappingSize no está presente, se usa el fileMappingSize valor de atributo del elemento especificado en el archivo Machine.config, lo que provoca una sobrecarga adicional para el performanceCounters procesamiento de archivos de configuración. Puede obtener una mejora del rendimiento para 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, consulte <performanceCounters>.

Constructores

PerformanceCounterCategory()	Inicializa una nueva instancia de la clase PerformanceCounterCategory, deja la propiedad CategoryName vacía y establece la propiedad MachineName en el equipo local.
PerformanceCounterCategory(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.
PerformanceCounterCategory(String, String)	Inicializa una nueva instancia de la clase PerformanceCounterCategory y establece las propiedades CategoryName y MachineName en los valores especificados.

Propiedades

CategoryHelp	Obtiene el texto de ayuda de la categoría.
CategoryName	Obtiene o establece el nombre del objeto de rendimiento que define esta categoría.
CategoryType	Obtiene el tipo de categoría de contador de rendimiento.
MachineName	Obtiene o establece el nombre del equipo en el que reside esta categoría.

Métodos

CounterExists(String)	Determina si el contador especificado está registrado en esta categoría; esta información se indica mediante las propiedades CategoryName y MachineName.
CounterExists(String, String)	Determina si el contador especificado está registrado en la categoría especificada del equipo local.
CounterExists(String, String, String)	Determina si el contador especificado está registrado en la categoría especificada de un equipo remoto.
Create(String, String, CounterCreationDataCollection)	Obsoletos. Registra la categoría de contador de rendimiento personalizada que contiene los contadores especificados en el equipo local.
Create(String, String, PerformanceCounterCategoryType, CounterCreationDataCollection)	Registra la categoría de contador de rendimiento personalizada que contiene los contadores especificados en el equipo local.
Create(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.
Create(String, String, String, String)	Obsoletos. Registra una categoría de contador de rendimiento personalizada que contiene un solo contador de tipo NumberOfItems32 en el equipo local.
Delete(String)	Quita la categoría y los contadores asociados del equipo local.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
Exists(String)	Determina si la categoría está registrada en el equipo local.
Exists(String, String)	Determina si la categoría está registrada en el equipo especificado.
GetCategories()	Recupera una lista de las categorías de contador de rendimiento registradas en el equipo local.
GetCategories(String)	Recupera una lista de las categorías de contador de rendimiento registradas en el equipo especificado.
GetCounters()	Recupera una lista de los contadores de una categoría de contador de rendimiento que contiene exactamente una instancia.
GetCounters(String)	Recupera una lista de los contadores de una categoría de contador de rendimiento que contiene una o más instancias.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetInstanceNames()	Recupera la lista de instancias de objetos de rendimiento asociados a esta categoría.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
InstanceExists(String)	Determina si la instancia de objeto de rendimiento especificada existe en la categoría identificada por la propiedad PerformanceCounterCategory de este objeto CategoryName.
InstanceExists(String, String)	Determina si una categoría especificada en el equipo local contiene la instancia de objeto de rendimiento especificada.
InstanceExists(String, String, String)	Determina si una categoría especificada en un equipo especificado contiene la instancia de objeto de rendimiento especificada.
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ReadCategory()	Lee todos los datos sobre el contador y la instancia de objeto de rendimiento asociados a esta categoría de contador de rendimiento.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Consulte también

• PerformanceCounter
• CounterCreationDataCollection
• CounterSample