PerformanceCounterCategory Klasse

Definition

Stellt ein Leistungsobjekt dar, das eine Kategorie von Leistungsindikatoren definiert.

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

Beispiele

Im folgenden Codebeispiel wird bestimmt, ob ein PerformanceCounter und sein PerformanceCounterCategory Auf dem lokalen Computer oder auf einem anderen Computer vorhanden ist. Wenn diese Objekte auf dem lokalen Computer nicht vorhanden sind, erstellt das Beispiel optional diese. Es verwendet die Exists Methode, um zu bestimmen, ob es PerformanceCounterCategory vorhanden ist. Wenn der PerformanceCounterCategory Wert nicht vorhanden ist und kein Zählername angegeben wird oder der Computer ein Remotecomputer ist, wird das Beispiel beendet.

Wenn ein PerformanceCounter Name angegeben wird, verwendet das Beispiel die CounterExists Methode und zeigt das Ergebnis für den Benutzer an. Wenn dies PerformanceCounter nicht der Fall ist, kann der Benutzer das PerformanceCounterCategory Neue PerformanceCounterlöschen und erneut erstellen. Wenn der Benutzer dies tut, wird die Kategorie mithilfe der Delete Methode gelöscht.

Wenn dies angefordert wird, erstellt das Beispiel jetzt die neue PerformanceCounterCategory und PerformanceCounter die Create Methode. Wenn ein Instanzname angegeben wird, verwendet das Beispiel die InstanceExists Methode und zeigt das Ergebnis an.

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

Hinweise

Wichtig

Das Erstellen oder Löschen eines Leistungsindikators erfordert die Synchronisierung des zugrunde liegenden Codes mithilfe eines benannten Mutex. Wenn eine hoch privilegierte Anwendung den benannten Mutex sperrt, wird versucht, einen Leistungsindikator zu erstellen oder zu löschen, wodurch die Anwendung nicht mehr reagiert, bis die Sperre freigegeben wird. Um dieses Problem zu vermeiden, erteilen Sie UnmanagedCode niemals die Berechtigung für nicht vertrauenswürdigen Code. Darüber hinaus UnmanagedCode kann die Berechtigung möglicherweise andere Berechtigungen umgehen und sollte nur hochgradig vertrauenswürdigen Code gewährt werden.

Die PerformanceCounterCategory Eigenschaft der CategoryName Instanz wird im Feld "Leistungsobjekt" des Dialogfelds "Leistungsindikator hinzufügen" der Anwendung "Leistungsanzeige" angezeigt.

Die PerformanceCounterCategory Klasse bietet mehrere Methoden für die Interaktion mit Zählern und Kategorien auf dem Computer. Mit den Create Methoden können Sie benutzerdefinierte Kategorien definieren. Die Delete Methode bietet eine Möglichkeit zum Entfernen von Kategorien vom Computer. Mit der GetCategories Methode können Sie die Liste der Kategorien anzeigen, während ReadCategory alle Zähler- und Instanzdaten abgerufen werden, die einer einzelnen Kategorie zugeordnet sind.

Ein Leistungsindikator veröffentlicht Leistungsdaten zu einer Anwendung. Kategorien umfassen physische Komponenten (z. B. Prozessoren, Datenträger und Arbeitsspeicher) und Systemobjekte (z. B. Prozesse und Threads). Systemzähler, die mit demselben Leistungsobjekt verknüpft sind, werden in eine Kategorie gruppiert, die ihren allgemeinen Fokus angibt. Wenn Sie eine Instanz der PerformanceCounter Klasse erstellen, geben Sie zuerst die Kategorie an, mit der die Komponente interagiert, und wählen Sie dann einen Zähler aus dieser Kategorie aus.

Eine Windows Leistungskategorie ist beispielsweise die Kategorie "Speicher". Systemindikatoren in dieser Kategorie verfolgen Speicherdaten wie die Anzahl der verfügbaren Bytes und die Anzahl der zwischengespeicherten Bytes. Wenn Sie mit den in Ihrer Anwendung zwischengespeicherten Bytes arbeiten möchten, erstellen Sie eine Instanz der PerformanceCounter Komponente, verbinden sie mit der Kategorie "Speicher", und wählen Sie dann den entsprechenden Zähler (in diesem Fall zwischengespeicherte Bytes) aus dieser Kategorie aus.

Obwohl Ihr System viele weitere Leistungskategorien zur Verfügung stellt, sind die Kategorien, mit denen Sie wahrscheinlich am häufigsten interagieren, den Cache, Den Speicher, Objekte, PhysischeDisk, Prozess, Prozessor, Server, System und Threadkategorien.

Wichtig

Die RemoveInstance Methode in der PerformanceCounter Klasse gibt den Indikator frei, und wenn die Wiederverwendungsoption für diese Kategorie ausgewählt ist, wird die Instanz des Zählers wiederverwendet. Dies kann zu einer Rennbedingung führen, wenn ein anderer Prozess oder sogar ein anderer Teil des Codes versucht, in die Zählerinstanz zu schreiben.

Hinweis

Es wird dringend empfohlen, dass während der Installation der Anwendung neue Leistungsindikatorenkategorien erstellt werden, nicht während der Ausführung der Anwendung. Auf diese Weise kann das Betriebssystem seine Liste der registrierten Leistungsindikatorenkategorien aktualisieren. Wenn die Liste nicht aktualisiert wurde, schlägt der Versuch, die Kategorie zu verwenden, fehl.

Hinweis

Leistungsindikatorenkategorien, die mit dem .NET Framework 2.0 installiert sind, verwenden separaten freigegebenen Arbeitsspeicher, wobei jede Leistungsindikatorkategorie einen eigenen Arbeitsspeicher aufweist. Sie können die Größe des separaten freigegebenen Arbeitsspeichers angeben, indem Sie einen DWORD mit dem Namen "FileMappingSize" im Registrierungsschlüssel HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<category name> \Performance erstellen. Der Wert "FileMappingSize" wird auf die Größe des freigegebenen Arbeitsspeichers der Kategorie festgelegt. Die Standardgröße ist 131072 Dezimalzahl. Wenn der Wert "FileMappingSize" nicht vorhanden ist, wird der fileMappingSize Attributwert für das performanceCounters in der Machine.config Datei angegebene Element verwendet, was zusätzlichen Aufwand für die Verarbeitung von Konfigurationsdateien verursacht. Sie können eine Leistungsverbesserung für den Anwendungsstart realisieren, indem Sie die Dateizuordnungsgröße in der Registrierung festlegen. Weitere Informationen zur Dateigröße der Dateizuordnung finden Sie unter <performanceCounters>.

Konstruktoren

PerformanceCounterCategory()

Initialisiert eine neue Instanz der PerformanceCounterCategory-Klasse, lässt die CategoryName-Eigenschaft leer und legt die MachineName-Eigenschaft auf den lokalen Computer fest.

PerformanceCounterCategory(String)

Initialisiert eine neue Instanz der PerformanceCounterCategory-Klasse, legt die CategoryName-Eigenschaft auf den angegebenen Wert und die MachineName-Eigenschaft auf den lokalen Computer fest.

PerformanceCounterCategory(String, String)

Initialisiert eine neue Instanz der PerformanceCounterCategory-Klasse und legt die CategoryName-Eigenschaft und die MachineName-Eigenschaft auf die angegebenen Werte fest.

Eigenschaften

CategoryHelp

Ruft den Hilfetext zu dieser Kategorie ab.

CategoryName

Ruft den Namen des Leistungsobjekts ab, das diese Kategorie definiert, oder legt diesen fest.

CategoryType

Ruft den Typ der Leistungsindikatorkategorie ab.

MachineName

Ruft den Namen des Computers ab, auf dem diese Kategorie vorhanden ist, oder legt diesen fest.

Methoden

CounterExists(String)

Bestimmt, ob der angegebene Zähler in dieser Kategorie registriert ist. Dies wird durch die CategoryName-Eigenschaft und die MachineName-Eigenschaft angegeben.

CounterExists(String, String)

Bestimmt, ob der angegebene Indikator in der angegebenen Kategorie auf dem lokalen Computer registriert ist.

CounterExists(String, String, String)

Bestimmt, ob der angegebene Indikator in der angegebenen Kategorie auf einem Remotecomputer registriert ist.

Create(String, String, CounterCreationDataCollection)
Veraltet.
Veraltet.
Veraltet.
Veraltet.

Registriert die benutzerdefinierte Leistungsindikatorkategorie, die die angegebenen Zähler enthält, auf dem lokalen Computer.

Create(String, String, PerformanceCounterCategoryType, CounterCreationDataCollection)

Registriert die benutzerdefinierte Leistungsindikatorkategorie, die die angegebenen Zähler enthält, auf dem lokalen Computer.

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

Registriert die benutzerdefinierte Leistungsindikatorkategorie, die einen einzelnen Indikator vom Typ NumberOfItems32 enthält, auf dem lokalen Computer.

Create(String, String, String, String)
Veraltet.
Veraltet.
Veraltet.
Veraltet.

Registriert eine benutzerdefinierte Leistungsindikatorkategorie, die einen einzelnen Indikator vom Typ NumberOfItems32 enthält, auf dem lokalen Computer.

Delete(String)

Entfernt die Kategorie und die zugeordneten Indikatoren vom lokalen Computer.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
Exists(String)

Bestimmt, ob die Kategorie auf dem lokalen Computer registriert ist.

Exists(String, String)

Bestimmt, ob die Kategorie auf dem angegebenen Computer registriert ist.

GetCategories()

Ruft eine Liste der auf dem lokalen Computer registrierten Leistungsindikatorkategorien ab.

GetCategories(String)

Ruft eine Liste der auf dem angegebenen Computer registrierten Leistungsindikatorkategorien ab.

GetCounters()

Ruft eine Liste von Indikatoren in einer Leistungsindikatorkategorie ab, die genau eine Instanz enthält.

GetCounters(String)

Ruft eine Liste von Indikatoren in einer Leistungsindikatorkategorie ab, die mindestens eine Instanz enthält.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetInstanceNames()

Ruft die Liste der Leistungsobjektinstanzen ab, die dieser Kategorie zugeordnet sind.

GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
InstanceExists(String)

Bestimmt, ob die angegebene Leistungsobjektinstanz in der Kategorie vorhanden ist, die durch die PerformanceCounterCategory-Eigenschaft dieses CategoryName-Objekts bezeichnet wird.

InstanceExists(String, String)

Bestimmt, ob die angegebene Kategorie auf dem lokalen Computer die angegebene Leistungsobjektinstanz enthält.

InstanceExists(String, String, String)

Bestimmt, ob eine angegebene Kategorie auf dem angegebenen Computer die angegebene Leistungsobjektinstanz enthält.

MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ReadCategory()

Liest sämtliche Daten für Indikator- und Leistungsobjektinstanzen, die dieser Leistungsindikatorkategorie zugeordnet sind.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Gilt für

Siehe auch