PerformanceCounterCategory Třída

Definice

Obor názvů:

System.Diagnostics

Sestavení:

System.Diagnostics.PerformanceCounter.dll

Zdroj:

PerformanceCounterCategory.cs

Představuje objekt výkonu, který definuje kategorii čítačů výkonu.

public ref class PerformanceCounterCategory sealed

public sealed class PerformanceCounterCategory

type PerformanceCounterCategory = class

Public NotInheritable Class PerformanceCounterCategory

Dědičnost

Object

PerformanceCounterCategory

Příklady

Následující příklad kódu určuje, zda a PerformanceCounter jeho PerformanceCounterCategory existence v místním počítači nebo v jiném počítači. Pokud tyto objekty v místním počítači neexistují, příklad je volitelně vytvoří. Používá metodu Exists k určení, zda existuje PerformanceCounterCategory . PerformanceCounterCategory Pokud neexistuje a není zadán žádný název čítače nebo pokud je počítač vzdáleným počítačem, příklad se ukončí.

PerformanceCounter Pokud je zadaný název, použije příklad metodu CounterExists a zobrazí výsledek uživateli. PerformanceCounter Pokud neexistuje, uživatel může odstranit a znovu vytvořit PerformanceCounterCategory novou PerformanceCounter. Pokud to uživatel provede, kategorie se pomocí Delete metody odstraní.

V případě požadavku teď příklad vytvoří novou PerformanceCounterCategory a PerformanceCounter pomocí Create metody. Pokud je zadán název instance, použije příklad metodu InstanceExists a zobrazí výsledek.

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

Poznámky

Důležité

Vytvoření nebo odstranění čítače výkonu vyžaduje synchronizaci základního kódu pomocí pojmenovaného mutexu. Pokud vysoce privilegovaná aplikace uzamkne pojmenovaný objekt mutex, pokusí se vytvořit nebo odstranit čítač výkonu, způsobí, že aplikace přestane reagovat, dokud se zámek nevolní. Chcete-li se tomuto problému vyhnout, nikdy neudělte UnmanagedCode oprávnění nedůvěryhodnému kódu. Kromě toho UnmanagedCode oprávnění potenciálně umožňují obejít jiná oprávnění a měla by být udělena pouze vysoce důvěryhodnému kódu.

PerformanceCounterCategory Vlastnost instance CategoryName se zobrazí v poli Objekt výkonu v dialogovém okně Přidat čítač aplikace Prohlížeč výkonu.

Třída PerformanceCounterCategory poskytuje několik metod pro interakci s čítači a kategoriemi v počítači. Metody Create umožňují definovat vlastní kategorie. Tato Delete metoda poskytuje způsob, jak z počítače odebrat kategorie. Tato GetCategories metoda umožňuje zobrazit seznam kategorií, zatímco ReadCategory načte všechna data čítače a instance přidružená k jedné kategorii.

Čítač výkonu publikuje údaje o výkonu aplikace. Kategorie zahrnují fyzické komponenty (například procesory, disky a paměť) a systémové objekty (například procesy a vlákna). Systémové čítače, které souvisejí se stejným objektem výkonu, jsou seskupené do kategorie, která označuje jejich společný fokus. Při vytváření instance PerformanceCounter třídy nejprve označíte kategorii, se kterou bude komponenta pracovat, a pak zvolíte čítač z této kategorie.

Například jedna kategorie čítače Windows je kategorie Paměť. Čítače systému v této kategorii sledují data paměti, jako je počet dostupných bajtů a počet bajtů uložených v mezipaměti. Pokud byste chtěli pracovat s bajty uloženými v mezipaměti vaší aplikace, vytvořili byste instanci PerformanceCounter komponenty, připojili ji k kategorii Paměť a pak z této kategorie vybrali příslušný čítač (v tomto případě bytes uložený v mezipaměti).

I když váš systém zpřístupňuje mnoho dalších kategorií čítačů, kategorie, se kterými budete pravděpodobně pracovat nejčastěji, jsou kategorie Cache, Memory, Objects, PhysicalDisk, Process, Processor, Server, System a Thread kategorie.

Důležité

Metoda RemoveInstance ve PerformanceCounter třídě uvolní čítač a pokud je pro tuto kategorii vybrána možnost opětovného použití, instance čítače bude znovu použita. To může způsobit stav časování, pokud se do instance čítače pokouší zapisovat jiný proces nebo dokonce jiná část kódu.

Poznámka:

Důrazně doporučujeme vytvořit nové kategorie čítačů výkonu během instalace aplikace, ne během provádění aplikace. Díky tomu může operační systém aktualizovat seznam registrovaných kategorií čítačů výkonu. Pokud se seznam neaktualizoval, pokus o použití kategorie selže.

Poznámka:

Kategorie čítačů výkonu nainstalované s .NET používají samostatnou sdílenou paměť, přičemž každá kategorie čítače výkonu má vlastní paměť. Velikost samostatné sdílené paměti můžete určit vytvořením DWORD s názvem FileMappingSize v klíči registru HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<název> kategorie\Výkon. Hodnota FileMappingSize je nastavena na velikost sdílené paměti kategorie. Výchozí velikost je 131072 desetinných míst. Pokud hodnota FileMappingSize není k dispozici, fileMappingSize použije se hodnota atributu performanceCounters pro prvek zadaný v souboru Machine.config, což způsobuje další režii při zpracování konfiguračního souboru. Zlepšení výkonu při spuštění aplikace můžete zjistit nastavením velikosti mapování souborů v registru. Další informace o velikosti mapování souborů naleznete v tématu <performanceCounters>.

Konstruktory

Name	Description
PerformanceCounterCategory()	Inicializuje novou instanci PerformanceCounterCategory třídy, ponechá vlastnost prázdnou CategoryName a nastaví MachineName vlastnost na místní počítač.
PerformanceCounterCategory(String, String)	Inicializuje novou instanci PerformanceCounterCategory třídy a nastaví CategoryName a MachineName vlastnosti na zadané hodnoty.
PerformanceCounterCategory(String)	Inicializuje novou instanci PerformanceCounterCategory třídy, nastaví CategoryName vlastnost na zadanou hodnotu a nastaví MachineName vlastnost na místní počítač.

Vlastnosti

Name	Description
CategoryHelp	Získá text nápovědy pro kategorii.
CategoryName	Získá nebo nastaví název objektu výkonu, který definuje tuto kategorii.
CategoryType	Získá typ kategorie čítače výkonu.
MachineName	Získá nebo nastaví název počítače, na kterém tato kategorie existuje.

Metody

Name	Description
CounterExists(String, String, String)	Určuje, zda je zadaný čítač registrován do zadané kategorie ve vzdáleném počítači.
CounterExists(String, String)	Určuje, zda je zadaný čítač registrován do zadané kategorie v místním počítači.
CounterExists(String)	Určuje, zda je zadaný čítač registrován v této kategorii, která je označena CategoryName vlastnostmi a MachineName vlastnostmi.
Create(String, String, CounterCreationDataCollection)	Zastaralé. Zaregistruje vlastní kategorii čítače výkonu obsahující zadané čítače v místním počítači.
Create(String, String, PerformanceCounterCategoryType, CounterCreationDataCollection)	Zaregistruje vlastní kategorii čítače výkonu obsahující zadané čítače v místním počítači.
Create(String, String, PerformanceCounterCategoryType, String, String)	Zaregistruje vlastní kategorii čítače výkonu obsahující jeden čítač typu NumberOfItems32 v místním počítači.
Create(String, String, String, String)	Zastaralé. Zaregistruje vlastní kategorii čítače výkonu obsahující jeden čítač typu NumberOfItems32 v místním počítači.
Delete(String)	Odebere kategorii a přidružené čítače z místního počítače.
Exists(String, String)	Určuje, zda je kategorie zaregistrována v zadaném počítači.
Exists(String)	Určuje, zda je kategorie registrována v místním počítači.
GetCategories()	Načte seznam kategorií čítačů výkonu registrovaných v místním počítači.
GetCategories(String)	Načte seznam kategorií čítačů výkonu registrovaných v zadaném počítači.
GetCounters()	Načte seznam čítačů v kategorii čítače výkonu, která obsahuje přesně jednu instanci.
GetCounters(String)	Načte seznam čítačů v kategorii čítače výkonu, která obsahuje jednu nebo více instancí.
GetInstanceNames()	Načte seznam instancí objektů výkonu přidružených k této kategorii.
InstanceExists(String, String, String)	Určuje, zda zadaná kategorie v zadaném počítači obsahuje zadanou instanci objektu výkonu.
InstanceExists(String, String)	Určuje, zda zadaná kategorie v místním počítači obsahuje zadanou instanci objektu výkonu.
InstanceExists(String)	Určuje, zda zadaná instance objektu výkonu existuje v kategorii, která je identifikována vlastností tohoto PerformanceCounterCategory objektu CategoryName .
ReadCategory()	Přečte všechna data instance čítače a objektu výkonu přidružená k této kategorii čítače výkonu.

Viz také

• PerformanceCounter
• CounterCreationDataCollection
• CounterSample