PerformanceCounterCategory Klasse

Definition

public ref class PerformanceCounterCategory sealed

public sealed class PerformanceCounterCategory

type PerformanceCounterCategory = class

Public NotInheritable Class PerformanceCounterCategory

Vererbung

Object

PerformanceCounterCategory

Beispiele

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

Wenn ein PerformanceCounter Name angegeben wird, verwendet das Beispiel die CounterExists -Methode und zeigt dem Benutzer das Ergebnis an. Wenn der PerformanceCounter nicht vorhanden ist, kann der Benutzer löschen und mit dem PerformanceCounterCategory neuen PerformanceCountererstellen. Wenn der Benutzer dies tut, wird die Kategorie mit der Delete -Methode gelöscht.

Wenn dies angefordert wird, erstellt das Beispiel nun das neue PerformanceCounterCategory und PerformanceCounter mithilfe der Create -Methode. Wenn ein instance Name 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

Die PerformanceCounterCategory Eigenschaft des CategoryName instance wird im Feld Leistungsobjekt des Dialogfelds Zähler hinzufügen der Performance Viewer-Anwendung angezeigt.

Die PerformanceCounterCategory -Klasse bietet mehrere Methoden für die Interaktion mit Indikatoren und Kategorien auf dem Computer. Mit Create den Methoden können Sie benutzerdefinierte Kategorien definieren. Die Delete -Methode bietet eine Möglichkeit, Kategorien vom Computer zu entfernen. Mit GetCategories der Methode können Sie die Liste der Kategorien anzeigen, während ReadCategory alle Zähler und instance Daten 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). Systemindikatoren, die sich auf dasselbe Leistungsobjekt beziehen, werden in einer Kategorie gruppiert, die ihren gemeinsamen Fokus angibt. Wenn Sie einen instance der PerformanceCounter -Klasse erstellen, geben Sie zuerst die Kategorie an, mit der die Komponente interagiert, und wählen dann einen Zähler aus dieser Kategorie aus.

Beispielsweise ist eine Windows-Leistungskategorie die Kategorie "Arbeitsspeicher". Systemindikatoren innerhalb dieser Kategorie verfolgen Speicherdaten wie die Anzahl der verfügbaren Bytes und die Anzahl der zwischengespeicherten Bytes nach. Wenn Sie mit den in Ihrer Anwendung zwischengespeicherten Bytes arbeiten möchten, erstellen Sie eine instance der PerformanceCounter Komponente, verbinden sie mit der Kategorie Arbeitsspeicher, und wählen Sie dann den entsprechenden Indikator (in diesem Fall zwischengespeicherte Bytes) aus dieser Kategorie aus.

Obwohl Ihr System viele weitere Leistungsindikatorenkategorien zur Verfügung stellt, sind die Kategorien Cache, Arbeitsspeicher, Objekte, PhysicalDisk, Prozess, Prozessor, Server, System und Thread wahrscheinlich am häufigsten.

Konstruktoren

Eigenschaften

Methoden

Gilt für:

Weitere Informationen

• PerformanceCounter
• CounterCreationDataCollection
• CounterSample