PerformanceCounterCategory Klasa

Definicja

Reprezentuje obiekt wydajności, który definiuje kategorię liczników wydajności.Represents a performance object, which defines a category of performance counters.

public ref class PerformanceCounterCategory sealed
public sealed class PerformanceCounterCategory
type PerformanceCounterCategory = class
Public NotInheritable Class PerformanceCounterCategory
Dziedziczenie
PerformanceCounterCategory

Przykłady

Poniższy przykład kodu określa, czy PerformanceCounter i PerformanceCounterCategory istnieje na komputerze lokalnym, czy na innym komputerze.The following code example determines whether a PerformanceCounter and its PerformanceCounterCategory exist on the local computer or on another computer. Jeśli te obiekty nie istnieją na komputerze lokalnym, Przykładowo można je utworzyć.If these objects do not exist on the local computer, the example optionally creates them. Używa metody, Exists Aby określić, czy PerformanceCounterCategory istnieje.It uses the Exists method to determine whether the PerformanceCounterCategory exists. Jeśli nie PerformanceCounterCategory istnieje i nie określono nazwy licznika lub jeśli komputer jest maszyną zdalną, przykład kończy się.If the PerformanceCounterCategory does not exist and no counter name is specified, or if the computer is a remote machine, the example exits.

W przypadku PerformanceCounter podanej nazwy, przykład używa CounterExists metody i wyświetla wynik dla użytkownika.If a PerformanceCounter name is provided, the example uses the CounterExists method and displays the result to the user. Jeśli nie PerformanceCounter istnieje, użytkownik może je usunąć i utworzyć ponownie PerformanceCounterCategory z nowym PerformanceCounter .If the PerformanceCounter does not exist, the user can delete and re-create the PerformanceCounterCategory with the new PerformanceCounter. Jeśli użytkownik robi to, kategoria zostanie usunięta przy użyciu Delete metody.If the user does so, the category is deleted using the Delete method.

Jeśli zażądano, w przykładzie tworzony jest nowy PerformanceCounterCategory i PerformanceCounter przy użyciu Create metody.If requested, the example now creates the new PerformanceCounterCategory and PerformanceCounter using the Create method. Jeśli nazwa wystąpienia jest określona, przykład używa InstanceExists metody i wyświetla wynik.If an instance name is specified, the example uses the InstanceExists method and displays the result.

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

Uwagi

Ważne

Tworzenie lub usuwanie licznika wydajności wymaga synchronizacji kodu bazowego przy użyciu nazwanego obiektu mutex.Creating or deleting a performance counter requires synchronization of the underlying code by using a named mutex. Jeśli aplikacja o wysokim poziomie uprawnień blokuje nazwany obiekt mutex, próby utworzenia lub usunięcia licznika wydajności powodują, że aplikacja przestanie odpowiadać do momentu zwolnienia blokady.If a highly privileged application locks the named mutex, attempts to create or delete a performance counter causes the application to stop responding until the lock is released. Aby uniknąć tego problemu, nigdy nie Udziel UnmanagedCode uprawnień do niezaufanego kodu.To help avoid this problem, never grant UnmanagedCode permission to untrusted code. Ponadto UnmanagedCode uprawnienie potencjalnie pozwala na obejście innych uprawnień i powinno być przyznawane tylko do wysoce zaufanego kodu.In addition, UnmanagedCode permission potentially allows other permissions to be bypassed and should only be granted to highly trusted code.

PerformanceCounterCategory CategoryName Właściwość wystąpienia jest wyświetlana w polu Obiekt wydajności w oknie dialogowym Dodaj licznik aplikacji Podgląd wydajności.The PerformanceCounterCategory instance's CategoryName property is displayed in the Performance Object field of the Performance Viewer application's Add Counter dialog box.

PerformanceCounterCategoryKlasa zawiera kilka metod współpracy z licznikami i kategoriami na komputerze.The PerformanceCounterCategory class provides several methods for interacting with counters and categories on the computer. CreateMetody umożliwiają definiowanie kategorii niestandardowych.The Create methods enable you to define custom categories. DeleteMetoda umożliwia usuwanie kategorii z komputera.The Delete method provides a way to remove categories from the computer. GetCategoriesMetoda umożliwia wyświetlenie listy kategorii, podczas gdy ReadCategory Pobiera wszystkie dane licznika i wystąpienia skojarzone z pojedynczą kategorią.The GetCategories method enables you to view the list of categories, while ReadCategory retrieves all the counter and instance data associated with a single category.

Licznik wydajności publikuje dane dotyczące wydajności aplikacji.A performance counter publishes performance data about an application. Kategorie obejmują składniki fizyczne (takie jak procesory, dyski i pamięć) oraz obiekty systemowe (na przykład procesy i wątki).Categories include physical components (such as processors, disks, and memory) and system objects (such as processes and threads). Liczniki systemowe, które są powiązane z tym samym obiektem wydajności, są pogrupowane w kategorię, która wskazuje ich typowy fokus.System counters that are related to the same performance object are grouped into a category that indicates their common focus. Gdy tworzysz wystąpienie PerformanceCounter klasy, najpierw wskaż kategorię, z którą będzie korzystać składnik, a następnie wybierz licznik z tej kategorii.When you create an instance of the PerformanceCounter class, you first indicate the category with which the component will interact, and then you choose a counter from that category.

Na przykład jedna kategoria licznika systemu Windows jest kategorią pamięci.For example, one Windows counter category is the Memory category. Liczniki systemowe w tej kategorii śledzą dane pamięci, takie jak liczba dostępnych bajtów i liczba buforowanych bajtów.System counters within this category track memory data such as the number of bytes available and the number of bytes cached. Jeśli chcesz korzystać z bajtów w pamięci podręcznej w aplikacji, Utwórz wystąpienie PerformanceCounter składnika, połącz je z kategorią pamięci, a następnie wybierz odpowiedni licznik (w tym przypadku bajty w pamięci podręcznej) z tej kategorii.If you wanted to work with the bytes cached in your application, you would create an instance of the PerformanceCounter component, connect it to the Memory category, and then pick the appropriate counter (in this case, Cached Bytes) from that category.

Mimo że system udostępnia wiele większej liczby kategorii liczników, kategorie, z którymi najprawdopodobniej będzie najczęściej korzystać, to pamięć podręczna, pamięć, obiekty, DyskFizyczny, procesy, procesory, serwery, systemy i wątki.Although your system makes many more counter categories available, the categories that you will probably interact with most frequently are the Cache, Memory, Objects, PhysicalDisk, Process, Processor, Server, System, and Thread categories.

Ważne

RemoveInstanceMetoda w PerformanceCounter klasie zwolni licznik i, jeśli wybrano opcję ponownego użycia dla tej kategorii, wystąpienie licznika zostanie ponownie użyte.The RemoveInstance method in the PerformanceCounter class will release the counter and, if the reuse option is selected for that category, the instance of the counter will be reused. Może to spowodować sytuację wyścigu, jeśli inny proces lub nawet inna część kodu próbuje zapisać w wystąpieniu licznika.This could cause a race condition if another process or even another part of the code is trying to write to the counter instance.

Uwaga

Zdecydowanie zaleca się utworzenie nowych kategorii licznika wydajności podczas instalacji aplikacji, a nie w trakcie wykonywania aplikacji.It is strongly recommended that new performance counter categories be created during the installation of the application, not during the execution of the application. Pozwala to czas na odświeżenie listy zarejestrowanych kategorii liczników wydajności przez system operacyjny.This allows time for the operating system to refresh its list of registered performance counter categories. Jeśli lista nie została odświeżona, próba użycia kategorii zakończy się niepowodzeniem.If the list has not been refreshed, the attempt to use the category will fail.

Uwaga

Kategorie licznika wydajności zainstalowane z .NET Framework 2,0 używają oddzielnej pamięci współdzielonej, z każdą kategorią licznika wydajności mającą własną pamięć.Performance counter categories installed with the .NET Framework 2.0 use separate shared memory, with each performance counter category having its own memory. Można określić rozmiar oddzielnej pamięci współdzielonej przez utworzenie typu DWORD o nazwie FileMappingSize w kluczu rejestru HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ <category name> \Performance.You can specify the size of separate shared memory by creating a DWORD named FileMappingSize in the registry key HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<category name> \Performance. Wartość FileMappingSize jest ustawiona na rozmiar pamięci współdzielonej kategorii.The FileMappingSize value is set to the shared memory size of the category. Domyślny rozmiar to 131072 dziesiętny.The default size is 131072 decimal. Jeśli wartość FileMappingSize nie jest obecna, zostanie fileMappingSize użyta wartość atrybutu dla performanceCounters elementu określonego w pliku Machine.config, co spowoduje dodatkowe obciążenie związane z przetwarzaniem plików konfiguracyjnych.If the FileMappingSize value is not present, the fileMappingSize attribute value for the performanceCounters element specified in the Machine.config file is used, causing additional overhead for configuration file processing. Zwiększenie wydajności uruchamiania aplikacji można zrealizować przez ustawienie rozmiaru mapowania plików w rejestrze.You can realize a performance improvement for application startup by setting the file mapping size in the registry. Aby uzyskać więcej informacji o rozmiarze mapowania plików, zobacz < liczniki wydajności > .For more information about the file mapping size, see <performanceCounters>.

Konstruktory

PerformanceCounterCategory()

Inicjuje nowe wystąpienie PerformanceCounterCategory klasy, pozostawia CategoryName Właściwość pustą i ustawia MachineName Właściwość na komputer lokalny.Initializes a new instance of the PerformanceCounterCategory class, leaves the CategoryName property empty, and sets the MachineName property to the local computer.

PerformanceCounterCategory(String)

Inicjuje nowe wystąpienie PerformanceCounterCategory klasy, ustawia CategoryName Właściwość na określoną wartość i ustawia MachineName Właściwość na komputer lokalny.Initializes a new instance of the PerformanceCounterCategory class, sets the CategoryName property to the specified value, and sets the MachineName property to the local computer.

PerformanceCounterCategory(String, String)

Inicjuje nowe wystąpienie PerformanceCounterCategory klasy i ustawia CategoryName MachineName właściwości i do określonych wartości.Initializes a new instance of the PerformanceCounterCategory class and sets the CategoryName and MachineName properties to the specified values.

Właściwości

CategoryHelp

Pobiera tekst pomocy kategorii.Gets the category's help text.

CategoryName

Pobiera lub ustawia nazwę obiektu wydajności, który definiuje tę kategorię.Gets or sets the name of the performance object that defines this category.

CategoryType

Pobiera typ kategorii licznika wydajności.Gets the performance counter category type.

MachineName

Pobiera lub ustawia nazwę komputera, na którym istnieje ta kategoria.Gets or sets the name of the computer on which this category exists.

Metody

CounterExists(String)

Określa, czy określony licznik jest zarejestrowany w tej kategorii, który jest wskazywany przez CategoryName MachineName właściwości i.Determines whether the specified counter is registered to this category, which is indicated by the CategoryName and MachineName properties.

CounterExists(String, String)

Określa, czy określony licznik jest zarejestrowany w określonej kategorii na komputerze lokalnym.Determines whether the specified counter is registered to the specified category on the local computer.

CounterExists(String, String, String)

Określa, czy określony licznik jest zarejestrowany w określonej kategorii na komputerze zdalnym.Determines whether the specified counter is registered to the specified category on a remote computer.

Create(String, String, CounterCreationDataCollection)
Nieaktualne.
Nieaktualne.
Nieaktualne.

Rejestruje kategorię niestandardowego licznika wydajności zawierającej określone liczniki na komputerze lokalnym.Registers the custom performance counter category containing the specified counters on the local computer.

Create(String, String, PerformanceCounterCategoryType, CounterCreationDataCollection)

Rejestruje kategorię niestandardowego licznika wydajności zawierającej określone liczniki na komputerze lokalnym.Registers the custom performance counter category containing the specified counters on the local computer.

Create(String, String, PerformanceCounterCategoryType, String, String)

Rejestruje kategorię niestandardowego licznika wydajności zawierającą pojedynczy licznik typu NumberOfItems32 na komputerze lokalnym.Registers the custom performance counter category containing a single counter of type NumberOfItems32 on the local computer.

Create(String, String, String, String)
Nieaktualne.
Nieaktualne.
Nieaktualne.

Rejestruje niestandardową kategorię licznika wydajności zawierającą pojedynczy licznik typu NumberOfItems32 na komputerze lokalnym.Registers a custom performance counter category containing a single counter of type NumberOfItems32 on the local computer.

Delete(String)

Usuwa kategorię i skojarzone z nią liczniki z komputera lokalnego.Removes the category and its associated counters from the local computer.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
Exists(String)

Określa, czy kategoria jest zarejestrowana na komputerze lokalnym.Determines whether the category is registered on the local computer.

Exists(String, String)

Określa, czy kategoria jest zarejestrowana na określonym komputerze.Determines whether the category is registered on the specified computer.

GetCategories()

Pobiera listę kategorii licznika wydajności, które są zarejestrowane na komputerze lokalnym.Retrieves a list of the performance counter categories that are registered on the local computer.

GetCategories(String)

Pobiera listę kategorii licznika wydajności, które są zarejestrowane na określonym komputerze.Retrieves a list of the performance counter categories that are registered on the specified computer.

GetCounters()

Pobiera listę liczników w kategorii licznika wydajności, która zawiera dokładnie jedno wystąpienie.Retrieves a list of the counters in a performance counter category that contains exactly one instance.

GetCounters(String)

Pobiera listę liczników w kategorii licznika wydajności, która zawiera co najmniej jedno wystąpienie.Retrieves a list of the counters in a performance counter category that contains one or more instances.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetInstanceNames()

Pobiera listę wystąpień obiektów wydajności skojarzonych z tą kategorią.Retrieves the list of performance object instances that are associated with this category.

GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
InstanceExists(String)

Określa, czy określone wystąpienie obiektu wydajności istnieje w kategorii, która jest identyfikowana przez PerformanceCounterCategory Właściwość tego obiektu CategoryName .Determines whether the specified performance object instance exists in the category that is identified by this PerformanceCounterCategory object's CategoryName property.

InstanceExists(String, String)

Określa, czy określona Kategoria na komputerze lokalnym zawiera określone wystąpienie obiektu wydajności.Determines whether a specified category on the local computer contains the specified performance object instance.

InstanceExists(String, String, String)

Określa, czy określona Kategoria na określonym komputerze zawiera określone wystąpienie obiektu wydajności.Determines whether a specified category on a specified computer contains the specified performance object instance.

MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
ReadCategory()

Odczytuje wszystkie dane wystąpienia licznika i wydajności, które są skojarzone z tą kategorią licznika wydajności.Reads all the counter and performance object instance data that is associated with this performance counter category.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)

Dotyczy

Zobacz też