PerformanceCounterCategory Třída

Definice

Obor názvů:

System.Diagnostics

Sestavení:

System.Diagnostics.PerformanceCounter.dll

Balíček:

System.Diagnostics.PerformanceCounter v8.0.0

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 PerformanceCounter a PerformanceCounterCategory existuje v místním nebo jiném počítači. Pokud tyto objekty v místním počítači neexistují, vytvoří je v příkladu volitelně. Používá metodu Exists k určení, zda PerformanceCounterCategory existuje. PerformanceCounterCategory Pokud neexistuje a není zadán žádný název čítače nebo pokud je počítač vzdálený počítač, příklad se ukončí.

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

Pokud je to požadováno, v příkladu se teď vytvoří nový PerformanceCounterCategory a PerformanceCounter pomocí Create metody . Pokud je zadán název instance, příklad použije 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 mutex. Pokud aplikace s vysokou úrovní oprávnění uzamkne pojmenovaný mutex, pokus o vytvoření nebo odstranění čítače výkonu způsobí, že aplikace přestane reagovat, dokud se zámek nespustí. Pokud chcete tomuto problému předejít, nikdy neudělujte UnmanagedCode oprávnění k nedůvěryhodnému kódu. Kromě toho UnmanagedCode oprávnění potenciálně umožňuje obejít jiná oprávnění a měla by být udělena pouze vysoce důvěryhodnému kódu.

Vlastnost PerformanceCounterCategory instance se CategoryName zobrazí v poli Objekt výkonu dialogového okna Přidat čítač aplikace Prohlížeč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. Metoda Delete poskytuje způsob, jak odebrat kategorie z počítače. Metoda GetCategories umožňuje zobrazit seznam kategorií a zároveň ReadCategory načte všechny čítače a data instance přidružené k jedné kategorii.

Čítač výkonu publikuje data 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 seskupeny do kategorie, která označuje jejich společné zaměření. Při vytváření instance PerformanceCounter třídy nejprve označíte kategorii, se kterou bude komponenta komunikovat, a pak zvolíte čítač z této kategorie.

Jedna kategorie čítačů Windows je například kategorie Paměť. Systémové čítače v této kategorii sledují data paměti, například 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 ve vaší aplikaci, vytvořili byste instanci PerformanceCounter komponenty, připojili byste ji ke kategorii Paměť a pak byste z této kategorie vybrali příslušný čítač (v tomto případě Bajty 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 Mezipaměť, Paměť, Objekty, Fyzický disk, Proces, Procesor, Server, Systém a Vlákno.

Důležité

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

Poznámka

Důrazně doporučujeme, aby se nové kategorie čítačů výkonu vytvářely během instalace aplikace, ne během provádění aplikace. Operační systém tak může aktualizovat seznam registrovaných kategorií čítačů výkonu. Pokud se seznam neaktualizoval, pokus o použití kategorie se nezdaří.

Poznámka

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

Konstruktory

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

Vlastnosti

CategoryHelp	Získá text nápovědy kategorie.
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 existuje tato kategorie.

Metody

CounterExists(String)	Určuje, zda je zadaný čítač registrován do této kategorie, což je určeno vlastnostmi CategoryName a MachineName .
CounterExists(String, String)	Určuje, zda je zadaný čítač registrován v zadané kategorii v místním počítači.
CounterExists(String, String, String)	Určuje, zda je zadaný čítač registrován do zadané kategorie na vzdáleném počítači.
Create(String, String, CounterCreationDataCollection)	Zastaralé. Registruje vlastní kategorii čítačů výkonu obsahující zadané čítače v místním počítači.
Create(String, String, PerformanceCounterCategoryType, CounterCreationDataCollection)	Registruje vlastní kategorii čítačů výkonu obsahující zadané čítače v místním počítači.
Create(String, String, PerformanceCounterCategoryType, String, String)	Registruje 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é. Registruje 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.
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
Exists(String)	Určuje, zda je kategorie registrována v místním počítači.
Exists(String, String)	Určuje, zda je kategorie registrována v zadaném počítači.
GetCategories()	Načte seznam kategorií čítačů výkonu, které jsou registrovány v místním počítači.
GetCategories(String)	Načte seznam kategorií čítačů výkonu, které jsou registrovány v zadaném počítači.
GetCounters()	Načte seznam čítačů v kategorii čítačů výkonu, která obsahuje právě jednu instanci.
GetCounters(String)	Načte seznam čítačů v kategorii čítačů výkonu, která obsahuje jednu nebo více instancí.
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetInstanceNames()	Načte seznam instancí objektů výkonu, které jsou přidruženy k této kategorii.
GetType()	Type Získá z aktuální instance. (Zděděno od Object)
InstanceExists(String)	Určuje, zda zadaná instance objektu výkonu existuje v kategorii, která je identifikována vlastností tohoto PerformanceCounterCategory objektu CategoryName .
InstanceExists(String, String)	Určuje, zda zadaná kategorie v místním počítači obsahuje zadanou instanci objektu výkonu.
InstanceExists(String, String, String)	Určuje, zda zadaná kategorie v zadaném počítači obsahuje zadanou instanci objektu výkonu.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
ReadCategory()	Načte všechna data instance čítače a objektu výkonu, která je přidružená k této kategorii čítačů výkonu.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)

Viz také

• PerformanceCounter
• CounterCreationDataCollection
• CounterSample