PerformanceCounter Osztály

Definíció

Névtér:: System.Diagnostics

Szerelvény:: System.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Egy Windows NT-teljesítményszámláló összetevőt jelöl.

public ref class PerformanceCounter sealed : System::ComponentModel::Component, System::ComponentModel::ISupportInitialize

public sealed class PerformanceCounter : System.ComponentModel.Component, System.ComponentModel.ISupportInitialize

type PerformanceCounter = class
    inherit Component
    interface ISupportInitialize

Public NotInheritable Class PerformanceCounter
Inherits Component
Implements ISupportInitialize

Öröklődés: Object

MarshalByRefObject

Component
PerformanceCounter

Megvalósítás: ISupportInitialize

Példák

Az alábbi példakód bemutatja, hogy az PerformanceCounter osztály milyen számlálótípust hoz létre és használ AverageCount64 . A példa kategóriákat hoz létre, számlálókat állít be, adatokat gyűjt a számlálókból, és meghívja az CounterSampleCalculator osztályt a teljesítményszámláló adatainak értelmezésére. A köztes és a végleges eredmények megjelennek a konzolablakban. További példák a teljesítményszámlálók egyéb típusaira: enumerálás PerformanceCounterType .

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics;

public class App
{
    private static PerformanceCounter avgCounter64Sample;
    private static PerformanceCounter avgCounter64SampleBase;

    public static void Main()
    {
        ArrayList samplesList = new ArrayList();

        // If the category does not exist, create the category and exit.
        // Performance counters should not be created and immediately used.
        // There is a latency time to enable the counters, they should be created
        // prior to executing the application that uses the counters.
        // Execute this sample a second time to use the category.
        if (SetupCategory())
            return;
        CreateCounters();
        CollectSamples(samplesList);
        CalculateResults(samplesList);
    }

    private static bool SetupCategory()
    {
        if ( !PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") )
        {

            CounterCreationDataCollection counterDataCollection = new CounterCreationDataCollection();

            // Add the counter.
            CounterCreationData averageCount64 = new CounterCreationData();
            averageCount64.CounterType = PerformanceCounterType.AverageCount64;
            averageCount64.CounterName = "AverageCounter64Sample";
            counterDataCollection.Add(averageCount64);

            // Add the base counter.
            CounterCreationData averageCount64Base = new CounterCreationData();
            averageCount64Base.CounterType = PerformanceCounterType.AverageBase;
            averageCount64Base.CounterName = "AverageCounter64SampleBase";
            counterDataCollection.Add(averageCount64Base);

            // Create the category.
            PerformanceCounterCategory.Create("AverageCounter64SampleCategory",
                "Demonstrates usage of the AverageCounter64 performance counter type.",
                PerformanceCounterCategoryType.SingleInstance, counterDataCollection);

            return(true);
        }
        else
        {
            Console.WriteLine("Category exists - AverageCounter64SampleCategory");
            return(false);
        }
    }

    private static void CreateCounters()
    {
        // Create the counters.

        avgCounter64Sample = new PerformanceCounter("AverageCounter64SampleCategory",
            "AverageCounter64Sample",
            false);


        avgCounter64SampleBase = new PerformanceCounter("AverageCounter64SampleCategory",
            "AverageCounter64SampleBase",
            false);

        avgCounter64Sample.RawValue=0;
        avgCounter64SampleBase.RawValue=0;
    }
    private static void CollectSamples(ArrayList samplesList)
    {

        Random r = new Random( DateTime.Now.Millisecond );

        // Loop for the samples.
        for (int j = 0; j < 100; j++)
        {

            int value = r.Next(1, 10);
            Console.Write(j + " = " + value);

            avgCounter64Sample.IncrementBy(value);

            avgCounter64SampleBase.Increment();

            if ((j % 10) == 9)
            {
                OutputSample(avgCounter64Sample.NextSample());
                samplesList.Add( avgCounter64Sample.NextSample() );
            }
            else
            {
                Console.WriteLine();
            }

            System.Threading.Thread.Sleep(50);
        }
    }

    private static void CalculateResults(ArrayList samplesList)
    {
        for(int i = 0; i < (samplesList.Count - 1); i++)
        {
            // Output the sample.
            OutputSample( (CounterSample)samplesList[i] );
            OutputSample( (CounterSample)samplesList[i+1] );

            // Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " +
                CounterSampleCalculator.ComputeCounterValue((CounterSample)samplesList[i],
                (CounterSample)samplesList[i+1]) );

            // Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " +
                MyComputeCounterValue((CounterSample)samplesList[i],
                (CounterSample)samplesList[i+1]) );
        }
    }

    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    //    Description - This counter type shows how many items are processed, on average,
    //        during an operation. Counters of this type display a ratio of the items
    //        processed (such as bytes sent) to the number of operations completed. The
    //        ratio is calculated by comparing the number of items processed during the
    //        last interval to the number of operations completed during the last interval.
    // Generic type - Average
    //      Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number
    //        of items processed during the last sample interval and the denominator (D)
    //        represents the number of operations completed during the last two sample
    //        intervals.
    //    Average (Nx - N0) / (Dx - D0)
    //    Example PhysicalDisk\ Avg. Disk Bytes/Transfer
    //++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    private static Single MyComputeCounterValue(CounterSample s0, CounterSample s1)
    {
        Single numerator = (Single)s1.RawValue - (Single)s0.RawValue;
        Single denomenator = (Single)s1.BaseValue - (Single)s0.BaseValue;
        Single counterValue = numerator / denomenator;
        return(counterValue);
    }

    // Output information about the counter sample.
    private static void OutputSample(CounterSample s)
    {
        Console.WriteLine("\r\n+++++++++++");
        Console.WriteLine("Sample values - \r\n");
        Console.WriteLine("   BaseValue        = " + s.BaseValue);
        Console.WriteLine("   CounterFrequency = " + s.CounterFrequency);
        Console.WriteLine("   CounterTimeStamp = " + s.CounterTimeStamp);
        Console.WriteLine("   CounterType      = " + s.CounterType);
        Console.WriteLine("   RawValue         = " + s.RawValue);
        Console.WriteLine("   SystemFrequency  = " + s.SystemFrequency);
        Console.WriteLine("   TimeStamp        = " + s.TimeStamp);
        Console.WriteLine("   TimeStamp100nSec = " + s.TimeStamp100nSec);
        Console.WriteLine("++++++++++++++++++++++");
    }
}

Imports System.Collections
Imports System.Collections.Specialized
Imports System.Diagnostics

 _

Public Class App

    Private Shared avgCounter64Sample As PerformanceCounter
    Private Shared avgCounter64SampleBase As PerformanceCounter


    Public Shared Sub Main()

        Dim samplesList As New ArrayList()
        'If the category does not exist, create the category and exit.
        'Performance counters should not be created and immediately used.
        'There is a latency time to enable the counters, they should be created
        'prior to executing the application that uses the counters.
        'Execute this sample a second time to use the counters.
        If Not (SetupCategory()) Then
            CreateCounters()
            CollectSamples(samplesList)
            CalculateResults(samplesList)
        End If

    End Sub

    Private Shared Function SetupCategory() As Boolean
        If Not PerformanceCounterCategory.Exists("AverageCounter64SampleCategory") Then

            Dim counterDataCollection As New CounterCreationDataCollection()

            ' Add the counter.
            Dim averageCount64 As New CounterCreationData()
            averageCount64.CounterType = PerformanceCounterType.AverageCount64
            averageCount64.CounterName = "AverageCounter64Sample"
            counterDataCollection.Add(averageCount64)

            ' Add the base counter.
            Dim averageCount64Base As New CounterCreationData()
            averageCount64Base.CounterType = PerformanceCounterType.AverageBase
            averageCount64Base.CounterName = "AverageCounter64SampleBase"
            counterDataCollection.Add(averageCount64Base)

            ' Create the category.
            PerformanceCounterCategory.Create("AverageCounter64SampleCategory", _
               "Demonstrates usage of the AverageCounter64 performance counter type.", _
                      PerformanceCounterCategoryType.SingleInstance, counterDataCollection)

            Return True
        Else
            Console.WriteLine("Category exists - AverageCounter64SampleCategory")
            Return False
        End If
    End Function 'SetupCategory

    Private Shared Sub CreateCounters()
        ' Create the counters.

        avgCounter64Sample = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64Sample", False)

        avgCounter64SampleBase = New PerformanceCounter("AverageCounter64SampleCategory", "AverageCounter64SampleBase", False)

        avgCounter64Sample.RawValue = 0
        avgCounter64SampleBase.RawValue = 0
    End Sub

    Private Shared Sub CollectSamples(ByVal samplesList As ArrayList)

        Dim r As New Random(DateTime.Now.Millisecond)

        ' Loop for the samples.
        Dim j As Integer
        For j = 0 To 99

            Dim value As Integer = r.Next(1, 10)
            Console.Write(j.ToString() + " = " + value.ToString())

            avgCounter64Sample.IncrementBy(value)

            avgCounter64SampleBase.Increment()

            If j Mod 10 = 9 Then
                OutputSample(avgCounter64Sample.NextSample())
                samplesList.Add(avgCounter64Sample.NextSample())
            Else
                Console.WriteLine()
            End If
            System.Threading.Thread.Sleep(50)
        Next j
    End Sub

    Private Shared Sub CalculateResults(ByVal samplesList As ArrayList)
        Dim i As Integer
        For i = 0 To (samplesList.Count - 1) - 1
            ' Output the sample.
            OutputSample(CType(samplesList(i), CounterSample))
            OutputSample(CType(samplesList((i + 1)), CounterSample))

            ' Use .NET to calculate the counter value.
            Console.WriteLine(".NET computed counter value = " + CounterSampleCalculator.ComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())

            ' Calculate the counter value manually.
            Console.WriteLine("My computed counter value = " + MyComputeCounterValue(CType(samplesList(i), CounterSample), CType(samplesList((i + 1)), CounterSample)).ToString())
        Next i
    End Sub

    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    '	Description - This counter type shows how many items are processed, on average,
    '		during an operation. Counters of this type display a ratio of the items 
    '		processed (such as bytes sent) to the number of operations completed. The  
    '		ratio is calculated by comparing the number of items processed during the 
    '		last interval to the number of operations completed during the last interval. 
    ' Generic type - Average
    '  	Formula - (N1 - N0) / (D1 - D0), where the numerator (N) represents the number 
    '		of items processed during the last sample interval and the denominator (D) 
    '		represents the number of operations completed during the last two sample 
    '		intervals. 
    '	Average (Nx - N0) / (Dx - D0)  
    '	Example PhysicalDisk\ Avg. Disk Bytes/Transfer 
    '++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++//++++++++
    Private Shared Function MyComputeCounterValue(ByVal s0 As CounterSample, ByVal s1 As CounterSample) As [Single]
        Dim numerator As [Single] = CType(s1.RawValue, [Single]) - CType(s0.RawValue, [Single])
        Dim denomenator As [Single] = CType(s1.BaseValue, [Single]) - CType(s0.BaseValue, [Single])
        Dim counterValue As [Single] = numerator / denomenator
        Return counterValue
    End Function 'MyComputeCounterValue

    ' Output information about the counter sample.
    Private Shared Sub OutputSample(ByVal s As CounterSample)
        Console.WriteLine(ControlChars.Lf + ControlChars.Cr + "+++++++++++")
        Console.WriteLine("Sample values - " + ControlChars.Lf + ControlChars.Cr)
        Console.WriteLine(("   BaseValue        = " + s.BaseValue.ToString()))
        Console.WriteLine(("   CounterFrequency = " + s.CounterFrequency.ToString()))
        Console.WriteLine(("   CounterTimeStamp = " + s.CounterTimeStamp.ToString()))
        Console.WriteLine(("   CounterType      = " + s.CounterType.ToString()))
        Console.WriteLine(("   RawValue         = " + s.RawValue.ToString()))
        Console.WriteLine(("   SystemFrequency  = " + s.SystemFrequency.ToString()))
        Console.WriteLine(("   TimeStamp        = " + s.TimeStamp.ToString()))
        Console.WriteLine(("   TimeStamp100nSec = " + s.TimeStamp100nSec.ToString()))
        Console.WriteLine("++++++++++++++++++++++")
    End Sub
End Class

Megjegyzések

Az PerformanceCounter összetevő használható a meglévő előre definiált vagy egyéni számlálók olvasására, valamint a teljesítményadatok egyéni számlálókon való közzétételére (írására).

A Windows Performance Monitor Számlálók hozzáadása párbeszédpanelen számos előre definiált számláló található. A .NET-keretrendszer teljesítményszámlálóiról a A teljesítményszámlálók című témakörben olvashat.

Ez a típus implementálja a IDisposable felületet. Ha befejezte a típus használatát, közvetlenül vagy közvetve kell megsemmisítenie. A típus közvetlen ártalmatlanításához hívja meg a Dispose metódust egy try/catch blokkban. Ha közvetve szeretné megsemmisíteni, használjon olyan nyelvi szerkezetet, mint a using (C#-ban) vagy Using (a Visual Basicben). További információ: "Az IDisposable-t megvalósító objektum használata" című szakasz a IDisposable felület témakörében.

Important

A .NET-keretrendszer 1.0-s és 1.1-s verzióiban ez az osztály megköveteli, hogy az azonnali hívók teljes mértékben megbízhatók legyenek. A .NET Framework 2.0-s verziójától kezdve ehhez az osztályhoz PerformanceCounterPermission szükséges adott műveletekhez. Erősen ajánlott, hogy PerformanceCounterPermission ne adjon meg félmegbízható kódot. A teljesítményszámlálók olvasásának és írásának képessége lehetővé teszi a kód számára olyan műveletek végrehajtását, mint például a végrehajtási folyamatok számbavétele és az ezekről szóló információk beszerzése.

Emellett egy PerformanceCounter objektum kevésbé megbízható kódnak való átadása biztonsági problémát is okozhat. Soha ne adjon át teljesítményszámláló objektumokat, például egy PerformanceCounterCategory vagy PerformanceCounter, kevésbé megbízható kódnak.

Ha teljesítményszámlálóból szeretne olvasni, hozzon létre egy osztálypéldányt PerformanceCounter , állítsa be a CategoryName, CounterNameés opcionálisan a InstanceName tulajdonságokat, MachineName majd hívja meg a NextValue metódust a teljesítményszámláló olvasásához.

A teljesítményszámláló adatainak közzétételéhez hozzon létre egy vagy több egyéni számlálót a PerformanceCounterCategory.Create metódussal, hozzon létre egy példányt az PerformanceCounter osztályból, állítsa be az CategoryName, CounterName és, opcionálisan vagy MachineName tulajdonságokat, InstanceName majd hívja meg az IncrementBy, Incrementvagy Decrement metódusokat, vagy állítsa be a RawValue tulajdonságot az egyéni számláló értékének módosításához.

Note

A Increment, IncrementByés Decrement metódusok összekapcsolásokkal frissítik a számláló értékét. Ez segít a számláló értékének pontosságában többszálú vagy többprocesszoros forgatókönyvekben, de teljesítménybeli büntetést is eredményez. Ha nincs szüksége az összekapcsolt műveletek által biztosított pontosságra, a tulajdonságot közvetlenül is frissítheti RawValue a teljesítmény ötszörösére. Többszálú forgatókönyvekben azonban a számláló értékének egyes frissítései figyelmen kívül hagyhatók, ami pontatlan adatokat eredményez.

A számláló a teljesítményadatok gyűjtésének mechanizmusa. A beállításjegyzék tárolja az összes számláló nevét, amelyek mindegyike a rendszer funkcióinak egy adott területéhez kapcsolódik. Ilyen például a processzor foglalt ideje, a memóriahasználat vagy a hálózati kapcsolaton keresztül fogadott bájtok száma.

Minden számláló egyedileg van azonosítva a nevével és helyével. Ugyanúgy, ahogyan a fájl elérési útja tartalmaz egy meghajtót, egy könyvtárat, egy vagy több alkönyvtárat és egy fájlnevet, a számláló adatai négy elemből állnak: a számítógépből, a kategóriából, a kategóriapéldányból és a számláló nevéből.

A számláló adatainak tartalmazniuk kell azt a kategóriát vagy teljesítményobjektumot, amelynél a számláló méri az adatokat. A számítógép kategóriái közé tartoznak a fizikai összetevők, például processzorok, lemezek és memória. Vannak rendszerkategóriák is, például folyamatok és szálak. Minden kategória egy funkcionális elemhez kapcsolódik a számítógépen belül, és hozzá vannak rendelve standard számlálók. Ezek az objektumok a 2000-es rendszerfigyelő Windows Számlálók hozzáadása párbeszédpanel Teljesítményobjektum legördülő listájában jelennek meg, és fel kell venni őket a számláló elérési útjára. A teljesítményadatok a kapcsolódó kategória szerint lesznek csoportosítva.

Bizonyos esetekben ugyanannak a kategóriának több példánya is létezhet. Több folyamat és szál fut egyszerre, és egyes számítógépek több processzort is tartalmaznak. A kategóriapéldányokat kategóriapéldányoknak nevezzük, és mindegyik példányhoz hozzá vannak rendelve standard számlálók. Ha egy kategória több példánysal is rendelkezhet, a számláló információi között szerepelnie kell egy példány-specifikációnak.

Ha olyan számlálók teljesítményadatait szeretné beolvasni, amelyek kezdeti vagy korábbi értéket igényeltek a szükséges számítás elvégzéséhez, hívja meg kétszer a NextValue metódust, és használja a visszaadott adatokat, ahogy az alkalmazás megköveteli.

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
PerformanceCounter()	Inicializálja az PerformanceCounter osztály új, írásvédett példányát anélkül, hogy a példányt bármilyen rendszer- vagy egyéni teljesítményszámlálóhoz társítanák.
PerformanceCounter(String, String, Boolean)	Inicializálja az PerformanceCounter osztály új, írásvédett vagy írási/olvasási példányát, és társítja a helyi számítógépen megadott rendszer- vagy egyéni teljesítményszámlálóval. Ez a konstruktor megköveteli, hogy a kategória egyetlen példányt tartalmazzon.
PerformanceCounter(String, String, String, Boolean)	Inicializálja az PerformanceCounter osztály új, írásvédett vagy írásvédett példányát, és társítja azt a helyi számítógép megadott rendszer- vagy egyéni teljesítményszámlálójával és kategóriapéldányával.
PerformanceCounter(String, String, String, String)	Inicializálja az PerformanceCounter osztály új, írásvédett példányát, és társítja azt a megadott rendszer- vagy egyéni teljesítményszámlálóhoz és kategóriapéldányhoz a megadott számítógépen.
PerformanceCounter(String, String, String)	Inicializálja az PerformanceCounter osztály új, írásvédett példányát, és társítja azt a helyi számítógépen megadott rendszer- vagy egyéni teljesítményszámlálóhoz és kategóriapéldányhoz.
PerformanceCounter(String, String)	Inicializálja az PerformanceCounter osztály új, írásvédett példányát, és társítja a helyi számítógépen megadott rendszer- vagy egyéni teljesítményszámlálóval. Ez a konstruktor megköveteli, hogy a kategória egyetlen példánysal rendelkezzen.

Mezők

Name	Description
DefaultFileMappingSize	Elavult. A teljesítményszámlálók által megosztott globális memória bájtban megadott méretét adja meg. Az alapértelmezett méret 524 288 bájt.

Tulajdonságok

Name	Description
CanRaiseEvents	Beolvas egy értéket, amely jelzi, hogy az összetevő képes-e eseményt létrehozni. (Öröklődés forrása Component)
CategoryName	Lekéri vagy beállítja ennek a teljesítményszámlálónak a teljesítményszámláló kategóriájának nevét.
Container	Lekéri a IContainer .Component (Öröklődés forrása Component)
CounterHelp	Lekéri a teljesítményszámláló leírását.
CounterName	Lekéri vagy beállítja a példányhoz PerformanceCounter társított teljesítményszámláló nevét.
CounterType	Lekéri a társított teljesítményszámláló számlálótípusát.
DesignMode	Olyan értéket kap, amely jelzi, hogy az Component aktuálisan tervezési módban van-e. (Öröklődés forrása Component)
Events	Lekéri az ehhez Componentcsatolt eseménykezelők listáját. (Öröklődés forrása Component)
InstanceLifetime	Lekéri vagy beállítja egy folyamat élettartamát.
InstanceName	Lekéri vagy beállítja a teljesítményszámláló példánynevét.
MachineName	Lekéri vagy beállítja a teljesítményszámláló számítógépnevét.
RawValue	Lekéri vagy beállítja ennek a számlálónak a nyers vagy nem számított értékét.
ReadOnly	Lekéri vagy beállít egy értéket, amely jelzi, hogy ez PerformanceCounter a példány írásvédett módban van-e.
Site	Lekéri vagy megadja a ISite értékét a Component-hez. (Öröklődés forrása Component)

Metódusok

Name	Description
BeginInit()	Megkezdi egy űrlapon vagy egy másik összetevő által használt példány inicializálását PerformanceCounter . Az inicializálás futásidőben történik.
Close()	Bezárja a teljesítményszámlálót, és felszabadítja a teljesítményszámláló példány által lefoglalt összes erőforrást.
CloseSharedResources()	Felszabadítja a számlálók által lefoglalt teljesítményszámláló-kódtár megosztott állapotát.
CreateObjRef(Type)	Létrehoz egy objektumot, amely tartalmazza a távoli objektumokkal való kommunikációhoz használt proxy létrehozásához szükséges összes releváns információt. (Öröklődés forrása MarshalByRefObject)
Decrement()	A társított teljesítményszámlálót egy hatékony atomi művelettel egyenként megcukkantja.
Dispose()	Felszabadítja a .-hez használt összes erőforrást Component. (Öröklődés forrása Component)
Dispose(Boolean)	Felszabadítja a felügyelt erőforrások által Component használt nem felügyelt erőforrásokat, és opcionálisan felszabadítja a felügyelt erőforrásokat. (Öröklődés forrása Component)
EndInit()	Egy űrlapon vagy egy másik összetevő által használt példány inicializálásának PerformanceCounter befejezése. Az inicializálás futásidőben történik.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetLifetimeService()	Lekéri a példány élettartamszabályzatát vezérlő aktuális élettartam-szolgáltatásobjektumot. (Öröklődés forrása MarshalByRefObject)
GetService(Type)	Olyan objektumot ad vissza, amely az általa vagy annak által Component Containernyújtott szolgáltatást jelöli. (Öröklődés forrása Component)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
Increment()	Egy hatékony atomi művelettel egyenként növeli a társított teljesítményszámlálót.
IncrementBy(Int64)	A társított teljesítményszámláló értékét egy hatékony atomi művelettel egy meghatározott mennyiséggel növeli vagy decrementeli.
InitializeLifetimeService()	Beolvas egy élettartam-szolgáltatásobjektumot a példány élettartam-szabályzatának szabályozásához. (Öröklődés forrása MarshalByRefObject)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
MemberwiseClone(Boolean)	Az aktuális MarshalByRefObject objektum sekély másolatát hozza létre. (Öröklődés forrása MarshalByRefObject)
NextSample()	Lekér egy számlálómintát, és visszaadja annak nyers vagy nem kiszámított értékét.
NextValue()	Lekér egy számlálómintát, és visszaadja a számított értéket.
RemoveInstance()	Törli az objektumtulajdonság InstanceName által megadott kategóriapéldánytPerformanceCounter.
ToString()	String A ( ha van) nevet tartalmazó értéket Componentad vissza. Ezt a módszert nem szabad felülírni. (Öröklődés forrása Component)

esemény

Name	Description
Disposed	Akkor fordul elő, ha az összetevőt a metódus hívása megsemmisíti Dispose() . (Öröklődés forrása Component)

A következőre érvényes:

Lásd még

Visszajelzés

Hasznosnak találta ezt az oldalt?