PerformanceCounterCategory PerformanceCounterCategory PerformanceCounterCategory PerformanceCounterCategory Class

Definizione

Rappresenta un oggetto delle prestazioni, che definisce una categoria di contatori delle prestazioni.Represents a performance object, which defines a category of performance counters.

public ref class PerformanceCounterCategory sealed
public sealed class PerformanceCounterCategory
type PerformanceCounterCategory = class
Public NotInheritable Class PerformanceCounterCategory
Ereditarietà
PerformanceCounterCategoryPerformanceCounterCategoryPerformanceCounterCategoryPerformanceCounterCategory

Esempi

L'esempio di codice seguente determina se un PerformanceCounter e il relativo PerformanceCounterCategory esiste nel computer locale o in un altro computer.The following code example determines whether a PerformanceCounter and its PerformanceCounterCategory exist on the local computer or on another computer. Se questi oggetti non esistono nel computer locale, l'esempio facoltativamente li crea.If these objects do not exist on the local computer, the example optionally creates them. Usa il Exists metodo per determinare se il PerformanceCounterCategory esiste.It uses the Exists method to determine whether the PerformanceCounterCategory exists. Se il PerformanceCounterCategory non esiste e viene specificato alcun nome di contatore o se il computer è un computer remoto, nell'esempio viene chiuso.If the PerformanceCounterCategory does not exist and no counter name is specified, or if the computer is a remote machine, the example exits.

Se un PerformanceCounter viene specificato il nome, l'esempio Usa il CounterExists (metodo) e visualizza il risultato all'utente.If a PerformanceCounter name is provided, the example uses the CounterExists method and displays the result to the user. Se il PerformanceCounter non esiste, l'utente può eliminare e ricreare il PerformanceCounterCategory con il nuovo PerformanceCounter.If the PerformanceCounter does not exist, the user can delete and re-create the PerformanceCounterCategory with the new PerformanceCounter. Se si esegue questa operazione, la categoria viene eliminata usando il Delete (metodo).If the user does so, the category is deleted using the Delete method.

Se richiesto, l'esempio verranno create le nuove PerformanceCounterCategory e PerformanceCounter usando il Create (metodo).If requested, the example now creates the new PerformanceCounterCategory and PerformanceCounter using the Create method. Se viene specificato un nome di istanza, l'esempio Usa il InstanceExists (metodo) e visualizza il risultato.If an instance name is specified, the example uses the InstanceExists method and displays the result.

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
Imports System.Diagnostics
Imports Microsoft.VisualBasic

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

Commenti

Importante

Creazione o eliminazione di un contatore delle prestazioni richiede la sincronizzazione del codice sottostante usando un mutex denominato.Creating or deleting a performance counter requires synchronization of the underlying code by using a named mutex. Se un'applicazione con privilegiata elevati consente di bloccare il mutex denominato, i tentativi di creazione o eliminazione di un contatore delle prestazioni, l'applicazione di rispondere fino a quando il blocco viene rilasciato.If a highly privileged application locks the named mutex, attempts to create or delete a performance counter causes the application to stop responding until the lock is released. Per evitare questo problema, non concedere mai UnmanagedCode dell'autorizzazione per codice non attendibile.To help avoid this problem, never grant UnmanagedCode permission to untrusted code. Inoltre, UnmanagedCode autorizzazione potenzialmente consente altre autorizzazioni è stata ignorata e deve essere concesso solo a codice completamente attendibile.In addition, UnmanagedCode permission potentially allows other permissions to be bypassed and should only be granted to highly trusted code.

Il PerformanceCounterCategory dell'istanza CategoryName proprietà viene visualizzata nel campo oggetto prestazione della finestra di dialogo Aggiungi contatori dell'applicazione contatori delle prestazioni.The PerformanceCounterCategory instance's CategoryName property is displayed in the Performance Object field of the Performance Viewer application's Add Counter dialog box.

Il PerformanceCounterCategory classe fornisce diversi metodi per l'interazione con i contatori e le categorie nel computer.The PerformanceCounterCategory class provides several methods for interacting with counters and categories on the computer. Il Create metodi consentono di definire categorie personalizzate.The Create methods enable you to define custom categories. Il Delete metodo fornisce un modo per rimuovere le categorie dal computer.The Delete method provides a way to remove categories from the computer. Il GetCategories metodo consente di visualizzare l'elenco di categorie, mentre ReadCategory recupera tutti i dati di contatore e istanza associati a una singola categoria.The GetCategories method enables you to view the list of categories, while ReadCategory retrieves all the counter and instance data associated with a single category.

Un contatore delle prestazioni pubblica i dati sulle prestazioni relative a un'applicazione.A performance counter publishes performance data about an application. Le categorie includono componenti fisici (ad esempio processori, dischi e memoria) e gli oggetti di sistema (ad esempio processi e thread).Categories include physical components (such as processors, disks, and memory) and system objects (such as processes and threads). Contatori di sistema che sono correlati allo stesso oggetto delle prestazioni sono raggruppati in una categoria che indica il comune stato attivo.System counters that are related to the same performance object are grouped into a category that indicates their common focus. Quando si crea un'istanza di PerformanceCounter (classe), è prima di tutto indicare la categoria con cui interagisce il componente e quindi si sceglie un contatore di tale categoria.When you create an instance of the PerformanceCounter class, you first indicate the category with which the component will interact, and then you choose a counter from that category.

Ad esempio, una categoria di contatori di Windows è la categoria di memoria.For example, one Windows counter category is the Memory category. I contatori di sistema all'interno di questa categoria di tenere traccia dei dati di memoria, ad esempio il numero di byte disponibili e il numero di byte memorizzate nella cache.System counters within this category track memory data such as the number of bytes available and the number of bytes cached. Se si desidera lavorare con i byte memorizzate nella cache nell'applicazione, si creerà un'istanza di PerformanceCounter componente, connetterla alla categoria di memoria e quindi scegliere il contatore appropriato (in questo caso, byte memorizzate nella cache) da tale categoria.If you wanted to work with the bytes cached in your application, you would create an instance of the PerformanceCounter component, connect it to the Memory category, and then pick the appropriate counter (in this case, Cached Bytes) from that category.

Anche se il sistema esegue molte altre categorie di contatori disponibili, le categorie che è probabile che interagirà con più di frequente sono le categorie di Cache, memoria, gli oggetti, disco fisico, processo, processore, Server, sistema e Thread.Although your system makes many more counter categories available, the categories that you will probably interact with most frequently are the Cache, Memory, Objects, PhysicalDisk, Process, Processor, Server, System, and Thread categories.

Importante

Il RemoveInstance nel metodo il PerformanceCounter classe rilascerà il contatore e, se è selezionata l'opzione di riutilizzo per quella categoria, verrà riutilizzato l'istanza del contatore.The RemoveInstance method in the PerformanceCounter class will release the counter and, if the reuse option is selected for that category, the instance of the counter will be reused. Ciò potrebbe causare una race condition, se un altro processo o persino un'altra parte del codice sta tentando di scrivere l'istanza del contatore.This could cause a race condition if another process or even another part of the code is trying to write to the counter instance.

Nota

È consigliabile che è possibile creare nuove categorie di contatori delle prestazioni durante l'installazione dell'applicazione, non durante l'esecuzione dell'applicazione.It is strongly recommended that new performance counter categories be created during the installation of the application, not during the execution of the application. In questo modo ora il sistema operativo aggiornare l'elenco di categorie di contatori delle prestazioni registrati.This allows time for the operating system to refresh its list of registered performance counter categories. Se l'elenco non è stato aggiornato, il tentativo di usare la categoria avrà esito negativo.If the list has not been refreshed, the attempt to use the category will fail.

Nota

Categorie di contatori delle prestazioni installate con il .NET Framework 2.0.NET Framework 2.0 utilizzo della memoria condivisa separata, con ogni categoria di contatori delle prestazioni disponga della propria memoria.Performance counter categories installed with the .NET Framework 2.0.NET Framework 2.0 use separate shared memory, with each performance counter category having its own memory. È possibile specificare le dimensioni della memoria condivisa separata tramite la creazione di un valore DWORD denominato FileMappingSize nella chiave del Registro di sistema HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<il nome di categoria > \ Prestazione.You can specify the size of separate shared memory by creating a DWORD named FileMappingSize in the registry key HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\<category name> \Performance. Il valore FileMappingSize è impostato per le dimensioni della memoria condivisa della categoria.The FileMappingSize value is set to the shared memory size of the category. La dimensione predefinita è 131.072 decimale.The default size is 131072 decimal. Se il valore FileMappingSize non è presente, il fileMappingSize valore dell'attributo di performanceCounters viene usato l'elemento specificato nel file Machine. config, causando un ulteriore sovraccarico per l'elaborazione di file di configurazione.If the FileMappingSize value is not present, the fileMappingSize attribute value for the performanceCounters element specified in the Machine.config file is used, causing additional overhead for configuration file processing. È possibile realizzare un miglioramento delle prestazioni per l'avvio dell'applicazione impostando le dimensioni del mapping dei file del Registro di sistema.You can realize a performance improvement for application startup by setting the file mapping size in the registry. Per altre informazioni sulla dimensione del mapping del file, vedere <performanceCounters>.For more information about the file mapping size, see <performanceCounters>.

Costruttori

PerformanceCounterCategory() PerformanceCounterCategory() PerformanceCounterCategory() PerformanceCounterCategory()

Consente di inizializzare una nuova istanza della classe PerformanceCounterCategory, lascia vuota la proprietà CategoryName e imposta la proprietà MachineName sul computer locale.Initializes a new instance of the PerformanceCounterCategory class, leaves the CategoryName property empty, and sets the MachineName property to the local computer.

PerformanceCounterCategory(String) PerformanceCounterCategory(String) PerformanceCounterCategory(String) PerformanceCounterCategory(String)

Consente di inizializzare una nuova istanza della classe PerformanceCounterCategory, imposta la proprietà CategoryName sul valore specificato e la proprietà MachineName sul computer locale.Initializes a new instance of the PerformanceCounterCategory class, sets the CategoryName property to the specified value, and sets the MachineName property to the local computer.

PerformanceCounterCategory(String, String) PerformanceCounterCategory(String, String) PerformanceCounterCategory(String, String) PerformanceCounterCategory(String, String)

Consente di inizializzare una nuova istanza della classe PerformanceCounterCategory e imposta le proprietà CategoryName e MachineName sui valori specificati.Initializes a new instance of the PerformanceCounterCategory class and sets the CategoryName and MachineName properties to the specified values.

Proprietà

CategoryHelp CategoryHelp CategoryHelp CategoryHelp

Ottiene il testo della Guida della categoria.Gets the category's help text.

CategoryName CategoryName CategoryName CategoryName

Ottiene o imposta il nome dell'oggetto delle prestazioni che definisce questa categoria.Gets or sets the name of the performance object that defines this category.

CategoryType CategoryType CategoryType CategoryType

Ottiene il tipo di categoria del contatore delle prestazioni.Gets the performance counter category type.

MachineName MachineName MachineName MachineName

Ottiene o imposta il nome del computer sul quale è presente questa categoria.Gets or sets the name of the computer on which this category exists.

Metodi

CounterExists(String) CounterExists(String) CounterExists(String) CounterExists(String)

Determina se il contatore specificato è registrato in questa categoria, indicata dalle proprietà CategoryName e MachineName.Determines whether the specified counter is registered to this category, which is indicated by the CategoryName and MachineName properties.

CounterExists(String, String) CounterExists(String, String) CounterExists(String, String) CounterExists(String, String)

Determina se il contatore specificato è registrato nella categoria specificata sul computer locale.Determines whether the specified counter is registered to the specified category on the local computer.

CounterExists(String, String, String) CounterExists(String, String, String) CounterExists(String, String, String) CounterExists(String, String, String)

Determina se il contatore specificato è registrato nella categoria specificata in un computer remoto.Determines whether the specified counter is registered to the specified category on a remote computer.

Create(String, String, CounterCreationDataCollection) Create(String, String, CounterCreationDataCollection) Create(String, String, CounterCreationDataCollection) Create(String, String, CounterCreationDataCollection)

Registra la categoria personalizzata di contatori delle prestazioni contenente i contatori specificati sul computer locale.Registers the custom performance counter category containing the specified counters on the local computer.

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

Registra la categoria personalizzata di contatori delle prestazioni contenente i contatori specificati sul computer locale.Registers the custom performance counter category containing the specified counters on the local computer.

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

Registra la categoria personalizzata di contatori delle prestazioni contenente un solo contatore di tipo NumberOfItems32 sul computer locale.Registers the custom performance counter category containing a single counter of type NumberOfItems32 on the local computer.

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

Registra una categoria personalizzata di contatori delle prestazioni contenente un solo contatore di tipo NumberOfItems32 sul computer locale.Registers a custom performance counter category containing a single counter of type NumberOfItems32 on the local computer.

Delete(String) Delete(String) Delete(String) Delete(String)

Rimuove la categoria e i contatori associati dal computer locale.Removes the category and its associated counters from the local computer.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Exists(String) Exists(String) Exists(String) Exists(String)

Determina se la categoria è registrata sul computer locale.Determines whether the category is registered on the local computer.

Exists(String, String) Exists(String, String) Exists(String, String) Exists(String, String)

Determina se la categoria è registrata sul computer specificato.Determines whether the category is registered on the specified computer.

GetCategories() GetCategories() GetCategories() GetCategories()

Recupera un elenco di categorie di contatori delle prestazioni registrate sul computer locale.Retrieves a list of the performance counter categories that are registered on the local computer.

GetCategories(String) GetCategories(String) GetCategories(String) GetCategories(String)

Recupera un elenco di categorie di contatori delle prestazioni registrate sul computer specificato.Retrieves a list of the performance counter categories that are registered on the specified computer.

GetCounters() GetCounters() GetCounters() GetCounters()

Recupera un elenco di contatori in una categoria di contatori delle prestazioni che contiene esattamente un'istanza.Retrieves a list of the counters in a performance counter category that contains exactly one instance.

GetCounters(String) GetCounters(String) GetCounters(String) GetCounters(String)

Recupera un elenco di contatori in una categoria di contatori delle prestazioni che contiene una o più istanze.Retrieves a list of the counters in a performance counter category that contains one or more instances.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetInstanceNames() GetInstanceNames() GetInstanceNames() GetInstanceNames()

Recupera l'elenco di istanze dell'oggetto delle prestazioni associate a questa categoria.Retrieves the list of performance object instances that are associated with this category.

GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
InstanceExists(String) InstanceExists(String) InstanceExists(String) InstanceExists(String)

Determina se l'istanza dell'oggetto delle prestazioni specificato è presente nella categoria identificata dalla proprietà PerformanceCounterCategory di questo oggetto CategoryName.Determines whether the specified performance object instance exists in the category that is identified by this PerformanceCounterCategory object's CategoryName property.

InstanceExists(String, String) InstanceExists(String, String) InstanceExists(String, String) InstanceExists(String, String)

Determina se una categoria specificata sul computer locale contiene l'istanza dell'oggetto delle prestazioni specificato.Determines whether a specified category on the local computer contains the specified performance object instance.

InstanceExists(String, String, String) InstanceExists(String, String, String) InstanceExists(String, String, String) InstanceExists(String, String, String)

Determina se una categoria specificata su un particolare computer contiene l'istanza dell'oggetto delle prestazioni specificato.Determines whether a specified category on a specified computer contains the specified performance object instance.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
ReadCategory() ReadCategory() ReadCategory() ReadCategory()

Legge tutti i dati relativi ai contatori e alle istanze dell'oggetto delle prestazioni associati a questa categoria di contatori delle prestazioni.Reads all the counter and performance object instance data that is associated with this performance counter category.

ToString() ToString() ToString() ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)

Si applica a

Vedi anche