PerformanceCounterCategory Klasa

Definicja

Przestrzeń nazw:

System.Diagnostics

Zestaw:

System.Diagnostics.PerformanceCounter.dll

Pakiet:

System.Diagnostics.PerformanceCounter v8.0.0

Źródło:

PerformanceCounterCategory.cs

Reprezentuje obiekt wydajności, który definiuje kategorię liczników wydajności.

public ref class PerformanceCounterCategory sealed

public sealed class PerformanceCounterCategory

type PerformanceCounterCategory = class

Public NotInheritable Class PerformanceCounterCategory

Dziedziczenie

Object

PerformanceCounterCategory

Przykłady

Poniższy przykład kodu określa, czy element PerformanceCounter i istnieje PerformanceCounterCategory na komputerze lokalnym, czy na innym komputerze. Jeśli te obiekty nie istnieją na komputerze lokalnym, przykład opcjonalnie je tworzy. Używa Exists metody , aby określić, czy PerformanceCounterCategory istnieje. Jeśli parametr PerformanceCounterCategory nie istnieje i nie określono nazwy licznika lub jeśli komputer jest maszyną zdalną, przykład kończy działanie.

PerformanceCounter Jeśli podano nazwę, w przykładzie użyto CounterExists metody i zostanie wyświetlony wynik dla użytkownika. Jeśli obiekt PerformanceCounter nie istnieje, użytkownik może usunąć i ponownie utworzyć element PerformanceCounterCategory za pomocą nowego PerformanceCounterelementu . Jeśli użytkownik to zrobi, kategoria zostanie usunięta Delete przy użyciu metody .

Jeśli jest to wymagane, przykład tworzy teraz nowy PerformanceCounterCategory i PerformanceCounter przy użyciu Create metody . Jeśli określono nazwę wystąpienia, w przykładzie użyto InstanceExists metody i zostanie wyświetlony wynik.

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 bazowego kodu przy użyciu nazwanego mutexu. Jeśli aplikacja o wysokim poziomie uprawnień blokuje nazwany mutex, próbuje utworzyć lub usunąć licznik wydajności powoduje, że aplikacja przestanie odpowiadać, dopóki blokada nie zostanie zwolniona. Aby uniknąć tego problemu, nigdy nie udzielaj UnmanagedCode uprawnień do niezaufanego kodu. Ponadto UnmanagedCode uprawnienie potencjalnie umożliwia obejście innych uprawnień i powinno zostać przyznane tylko wysoce zaufany kod.

PerformanceCounterCategory Właściwość wystąpienia jest wyświetlana CategoryName w polu Obiekt wydajności okna dialogowego Dodawanie licznika aplikacji Podgląd wydajności.

Klasa PerformanceCounterCategory udostępnia kilka metod interakcji z licznikami i kategoriami na komputerze. Metody Create umożliwiają definiowanie kategorii niestandardowych. Metoda Delete umożliwia usunięcie kategorii z komputera. Metoda GetCategories umożliwia wyświetlenie listy kategorii, a jednocześnie ReadCategory pobiera wszystkie dane licznika i wystąpienia skojarzone z jedną kategorią.

Licznik wydajności publikuje dane wydajności dotyczące aplikacji. Kategorie obejmują składniki fizyczne (takie jak procesory, dyski i pamięć) oraz obiekty systemowe (takie jak procesy i wątki). Liczniki systemowe powiązane z tym samym obiektem wydajności są pogrupowane w kategorię, która wskazuje ich wspólny fokus. Podczas tworzenia wystąpienia PerformanceCounter klasy należy najpierw wskazać kategorię, z którą składnik będzie wchodzić w interakcje, a następnie wybierasz licznik z tej kategorii.

Na przykład jedną kategorią licznika systemu Windows jest kategoria Pamięć. Liczniki systemowe w tej kategorii śledzą dane pamięci, takie jak liczba dostępnych bajtów i liczba bajtów buforowanych. Jeśli chcesz pracować z bajtami buforowanym w aplikacji, utwórz wystąpienie PerformanceCounter składnika, połącz je z kategorią Pamięć, a następnie wybierz odpowiedni licznik (w tym przypadku buforowane bajty) z tej kategorii.

Mimo że system udostępnia wiele innych kategorii liczników, kategorie, z którymi prawdopodobnie będziesz korzystać, to kategorie pamięci podręcznej, pamięci, obiektów, dysk fizyczny, proces, procesor, serwer, system i wątki.

Ważne

Metoda RemoveInstance w PerformanceCounter klasie zwolni licznik, a jeśli dla tej kategorii zostanie wybrana opcja ponownego użycia, wystąpienie licznika zostanie ponownie użyte. Może to spowodować wystąpienie wyścigu, jeśli inny proces lub nawet inna część kodu próbuje zapisać w wystąpieniu licznika.

Uwaga

Zdecydowanie zaleca się utworzenie nowych kategorii liczników wydajności podczas instalacji aplikacji, a nie podczas wykonywania aplikacji. Dzięki temu system operacyjny może odświeżyć listę zarejestrowanych kategorii liczników wydajności. Jeśli lista nie została odświeżona, próba użycia kategorii zakończy się niepowodzeniem.

Uwaga

Kategorie liczników wydajności zainstalowane z .NET Framework 2.0 używają oddzielnej pamięci udostępnionej, a każda kategoria licznika wydajności ma własną pamięć. Można określić rozmiar oddzielnej pamięci udostępnionej, tworząc DWORD o nazwie FileMappingSize w kluczu rejestru HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<nazwa> kategorii\Wydajność. Wartość FileMappingSize jest ustawiona na rozmiar pamięci udostępnionej kategorii. Domyślny rozmiar to 131072 dziesiętny. Jeśli wartość FileMappingSize nie jest obecna, fileMappingSize używana jest wartość atrybutu performanceCounters elementu określona w pliku Machine.config, co powoduje dodatkowe obciążenie związane z przetwarzaniem plików konfiguracji. Możesz zrealizować poprawę wydajności uruchamiania aplikacji, ustawiając rozmiar mapowania plików w rejestrze. Aby uzyskać więcej informacji na temat rozmiaru mapowania plików, zobacz <performanceCounters>.

Konstruktory

PerformanceCounterCategory()	Inicjuje PerformanceCounterCategory nowe wystąpienie klasy, pozostawia właściwość pustą CategoryName i ustawia MachineName właściwość na komputer lokalny.
PerformanceCounterCategory(String)	Inicjuje PerformanceCounterCategory nowe wystąpienie klasy, ustawia CategoryName właściwość na określoną wartość i ustawia MachineName właściwość na komputer lokalny.
PerformanceCounterCategory(String, String)	Inicjuje PerformanceCounterCategory nowe wystąpienie klasy i ustawia CategoryName właściwości i MachineName na określone wartości.

Właściwości

CategoryHelp	Pobiera tekst pomocy kategorii.
CategoryName	Pobiera lub ustawia nazwę obiektu wydajności, który definiuje tę kategorię.
CategoryType	Pobiera typ kategorii licznika wydajności.
MachineName	Pobiera lub ustawia nazwę komputera, na którym istnieje ta kategoria.

Metody

CounterExists(String)	Określa, czy określony licznik jest zarejestrowany w tej kategorii, który jest wskazywany przez CategoryName właściwości i MachineName .
CounterExists(String, String)	Określa, czy określony licznik jest zarejestrowany w określonej kategorii na komputerze lokalnym.
CounterExists(String, String, String)	Określa, czy określony licznik jest zarejestrowany w określonej kategorii na komputerze zdalnym.
Create(String, String, CounterCreationDataCollection)	Przestarzałe. Rejestruje niestandardową kategorię licznika wydajności zawierającą określone liczniki na komputerze lokalnym.
Create(String, String, PerformanceCounterCategoryType, CounterCreationDataCollection)	Rejestruje niestandardową kategorię licznika wydajności zawierającą określone liczniki na komputerze lokalnym.
Create(String, String, PerformanceCounterCategoryType, String, String)	Rejestruje niestandardową kategorię licznika wydajności zawierającą jeden licznik typu NumberOfItems32 na komputerze lokalnym.
Create(String, String, String, String)	Przestarzałe. Rejestruje niestandardową kategorię licznika wydajności zawierającą jeden licznik typu NumberOfItems32 na komputerze lokalnym.
Delete(String)	Usuwa kategorię i skojarzone z nią liczniki z komputera lokalnego.
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
Exists(String)	Określa, czy kategoria jest zarejestrowana na komputerze lokalnym.
Exists(String, String)	Określa, czy kategoria jest zarejestrowana na określonym komputerze.
GetCategories()	Pobiera listę kategorii liczników wydajności zarejestrowanych na komputerze lokalnym.
GetCategories(String)	Pobiera listę kategorii liczników wydajności zarejestrowanych na określonym komputerze.
GetCounters()	Pobiera listę liczników w kategorii liczników wydajności, która zawiera dokładnie jedno wystąpienie.
GetCounters(String)	Pobiera listę liczników w kategorii licznika wydajności, która zawiera co najmniej jedno wystąpienie.
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetInstanceNames()	Pobiera listę wystąpień obiektów wydajności skojarzonych z tą kategorią.
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
InstanceExists(String)	Określa, czy określone wystąpienie obiektu wydajności istnieje w kategorii, która jest identyfikowana przez właściwość tego PerformanceCounterCategory obiektu CategoryName .
InstanceExists(String, String)	Określa, czy określona kategoria na komputerze lokalnym zawiera określone wystąpienie obiektu wydajności.
InstanceExists(String, String, String)	Określa, czy określona kategoria na określonym komputerze zawiera określone wystąpienie obiektu wydajności.
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
ReadCategory()	Odczytuje wszystkie dane licznika i wystąpienia obiektu wydajności skojarzone z tą kategorią licznika wydajności.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)

Zobacz też

• PerformanceCounter
• CounterCreationDataCollection
• CounterSample