PerformanceCounterCategory Osztály

Definíció

Névtér:

System.Diagnostics

Szerelvény:

System.Diagnostics.PerformanceCounter.dll

Csomag:

System.Diagnostics.PerformanceCounter v11.0.0-preview.5.26302.115

Forrás:

PerformanceCounterCategory.cs

Teljesítményobjektumot jelöl, amely a teljesítményszámlálók kategóriáját határozza meg.

public ref class PerformanceCounterCategory sealed

public sealed class PerformanceCounterCategory

type PerformanceCounterCategory = class

Public NotInheritable Class PerformanceCounterCategory

Öröklődés

Object

PerformanceCounterCategory

Példák

Az alábbi példakód azt határozza meg, hogy egy PerformanceCounter és annak PerformanceCounterCategory létezik-e a helyi számítógépen vagy egy másik számítógépen. Ha ezek az objektumok nem léteznek a helyi számítógépen, a példa opcionálisan létrehozza őket. A metódus használatával Exists állapítja meg, hogy létezik-e.PerformanceCounterCategory Ha a PerformanceCounterCategory számítógép nem létezik, és nincs megadva számlálónév, vagy ha a számítógép távoli gép, a példa kilép.

Ha megad egy PerformanceCounter nevet, a példa a metódust CounterExists használja, és megjeleníti az eredményt a felhasználónak. Ha a PerformanceCounter rendszer nem létezik, a felhasználó törölheti és újra létrehozhatja az PerformanceCounterCategory újat PerformanceCounter. Ha a felhasználó ezt teszi, a kategória a módszerrel törlődik Delete .

Ha kéri, a példa most létrehozza az újat PerformanceCounterCategory , és PerformanceCounter használja a metódust Create . Ha egy példánynév van megadva, a példa a metódust InstanceExists használja, és megjeleníti az eredményt.

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

Megjegyzések

Important

A teljesítményszámláló létrehozásához vagy törléséhez szinkronizálni kell a mögöttes kódot egy nevesített mutex használatával. Ha egy magas jogosultságú alkalmazás zárolja a nevesített mutexet, a teljesítményszámláló létrehozására vagy törlésére tett kísérletek hatására az alkalmazás a zárolás feloldásáig nem válaszol. A probléma elkerülése érdekében soha ne adjon UnmanagedCode engedélyt a nem megbízható kódra. Emellett az engedély más engedélyek megkerülését is lehetővé teszi, UnmanagedCode és csak magas megbízhatóságú kóddal adható meg.

A PerformanceCounterCategory példány tulajdonsága CategoryName a Teljesítménymegjelenítő alkalmazás Számláló hozzáadása párbeszédpanelJének Teljesítményobjektum mezőjében jelenik meg.

Az PerformanceCounterCategory osztály számos módszert kínál a számlálókkal és a kategóriákkal való interakcióhoz a számítógépen. A Create metódusokkal egyéni kategóriákat határozhat meg. A Delete módszer lehetővé teszi a kategóriák eltávolítását a számítógépről. A GetCategories módszer lehetővé teszi a kategóriák listájának megtekintését, miközben ReadCategory lekéri az egyetlen kategóriához társított számláló- és példányadatokat.

A teljesítményszámláló közzéteszi az alkalmazás teljesítményadatait. A kategóriák közé tartoznak a fizikai összetevők (például processzorok, lemezek és memória) és a rendszerobjektumok (például folyamatok és szálak). Az ugyanahhoz a teljesítményobjektumhoz kapcsolódó rendszerszámlálók olyan kategóriába vannak csoportosítva, amely a közös fókuszt jelzi. Az osztály egy példányának PerformanceCounter létrehozásakor először azt a kategóriát jelöli meg, amellyel az összetevő interakcióba lép, majd kiválaszt egy számlálót az adott kategóriából.

Az egyik Windows számláló kategória például a Memória kategória. A kategória rendszerszámlálói nyomon követik a memóriaadatokat, például a rendelkezésre álló bájtok számát és a gyorsítótárazott bájtok számát. Ha az alkalmazásban gyorsítótárazott bájtokkal szeretne dolgozni, létre kell hoznia az PerformanceCounter összetevő egy példányát, csatlakoztatnia kell a Memória kategóriához, majd kiválasztania a megfelelő számlálót (ebben az esetben a gyorsítótárazott bájtokat) az adott kategóriából.

Bár a rendszer sokkal több számlálókategóriát tesz elérhetővé, a leggyakrabban használt kategóriák a Gyorsítótár, a Memória, az Objektumok, a PhysicalDisk, a Folyamat, a Processzor, a Kiszolgáló, a Rendszer és a Szál kategóriák.

Important

Az RemoveInstance osztály metódusa PerformanceCounter felszabadítja a számlálót, és ha az adott kategóriához az újrafelhasználási lehetőség van kiválasztva, a számláló példánya újra felhasználható lesz. Ez versenyhelyzetet okozhat, ha egy másik folyamat vagy a kód egy másik része próbál írni a számlálópéldányra.

Note

Erősen ajánlott új teljesítményszámlálókat létrehozni az alkalmazás telepítése során, nem pedig az alkalmazás végrehajtása során. Így az operációs rendszer frissítheti a regisztrált teljesítményszámláló-kategóriák listáját. Ha a lista nem frissült, a kategória használatára tett kísérlet sikertelen lesz.

Note

A .NET telepített teljesítményszámláló-kategóriák külön megosztott memóriát használnak, és minden teljesítményszámláló-kategória saját memóriával rendelkezik. A különálló megosztott memória méretét úgy adhatja meg, hogy létrehoz egy FileMappingSize nevű DWORD-t a beállításkulcsban, HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<kategórianév>\Teljesítmény. A FileMappingSize érték a kategória megosztott memóriaméretére van állítva. Az alapértelmezett méret 131072 decimális. Ha a FileMappingSize érték nem található, a rendszer a fileMappingSize Machine.config fájlban megadott elem attribútumértékét performanceCounters használja, ami további többletterhelést okoz a konfigurációs fájlok feldolgozásához. A beállításjegyzék fájlleképezési méretének beállításával teljesítménybeli javulást érhet el az alkalmazás indításakor. A fájlleképezés méretével kapcsolatos további információkért lásd <: performanceCounters>.

Konstruktorok

Name	Description
PerformanceCounterCategory()	Inicializálja az PerformanceCounterCategory osztály új példányát, üresen hagyja a CategoryName tulajdonságot, és beállítja a MachineName tulajdonságot a helyi számítógépre.
PerformanceCounterCategory(String, String)	Inicializálja az PerformanceCounterCategory osztály új példányát, és beállítja a CategoryNameMachineName tulajdonságokat a megadott értékekre.
PerformanceCounterCategory(String)	Inicializálja az PerformanceCounterCategory osztály új példányát, beállítja a CategoryName tulajdonságot a megadott értékre, és beállítja a MachineName tulajdonságot a helyi számítógépre.

Tulajdonságok

Name	Description
CategoryHelp	Lekéri a kategória súgószövegét.
CategoryName	Lekéri vagy beállítja a kategóriát meghatározó teljesítményobjektum nevét.
CategoryType	Lekéri a teljesítményszámláló kategóriatípusát.
MachineName	Lekéri vagy beállítja annak a számítógépnek a nevét, amelyen ez a kategória létezik.

Metódusok

Name	Description
CounterExists(String, String, String)	Meghatározza, hogy a megadott számláló regisztrálva van-e a megadott kategóriához egy távoli számítógépen.
CounterExists(String, String)	Meghatározza, hogy a megadott számláló regisztrálva van-e a helyi számítógépen a megadott kategóriához.
CounterExists(String)	Meghatározza, hogy a megadott számláló regisztrálva van-e ehhez a kategóriához, amelyet a CategoryName tulajdonságok jeleznek MachineName .
Create(String, String, CounterCreationDataCollection)	Elavult. Regisztrálja a helyi számítógépen megadott számlálókat tartalmazó egyéni teljesítményszámláló kategóriát.
Create(String, String, PerformanceCounterCategoryType, CounterCreationDataCollection)	Regisztrálja a helyi számítógépen megadott számlálókat tartalmazó egyéni teljesítményszámláló kategóriát.
Create(String, String, PerformanceCounterCategoryType, String, String)	Regisztrálja az egyéni teljesítményszámláló kategóriát, amely egyetlen típusú NumberOfItems32 számlálót tartalmaz a helyi számítógépen.
Create(String, String, String, String)	Elavult. Regisztrál egy egyéni teljesítményszámláló kategóriát, amely egyetlen típusú NumberOfItems32 számlálót tartalmaz a helyi számítógépen.
Delete(String)	Eltávolítja a kategóriát és a hozzá tartozó számlálókat a helyi számítógépről.
Exists(String, String)	Meghatározza, hogy a kategória regisztrálva van-e a megadott számítógépen.
Exists(String)	Meghatározza, hogy a kategória regisztrálva van-e a helyi számítógépen.
GetCategories()	Lekéri a helyi számítógépen regisztrált teljesítményszámláló-kategóriák listáját.
GetCategories(String)	Lekéri a megadott számítógépen regisztrált teljesítményszámláló-kategóriák listáját.
GetCounters()	Lekéri a teljesítményszámlálók kategóriájának számlálóinak listáját, amely pontosan egy példányt tartalmaz.
GetCounters(String)	Egy vagy több példányt tartalmazó teljesítményszámláló-kategória számlálóinak listáját kéri le.
GetInstanceNames()	Lekéri az ehhez a kategóriához társított teljesítményobjektum-példányok listáját.
InstanceExists(String, String, String)	Meghatározza, hogy egy adott számítógép adott kategóriája tartalmazza-e a megadott teljesítményobjektum-példányt.
InstanceExists(String, String)	Meghatározza, hogy a helyi számítógépen található adott kategória tartalmazza-e a megadott teljesítményobjektum-példányt.
InstanceExists(String)	Meghatározza, hogy a megadott teljesítményobjektum-példány létezik-e abban a kategóriában, amelyet az PerformanceCounterCategory objektum tulajdonsága CategoryName azonosít.
ReadCategory()	Beolvassa az összes számláló- és teljesítményobjektum-példány adatait, amelyek ehhez a teljesítményszámláló-kategóriához tartoznak.

Lásd még

• PerformanceCounter
• CounterCreationDataCollection
• CounterSample