.NET-Runtime-Metriken
In diesem Artikel werden die integrierten Metriken für .NET-Laufzeitbibliotheken beschrieben, die mit der System.Diagnostics.Metrics API erstellt werden. Eine Liste der Metriken, die auf der älteren EventCounters-API basieren, finden Sie unter Verfügbare Zähler.
Tipp
Weitere Informationen zum Sammeln und Melden dieser Metriken finden Sie unter Sammeln von Metriken.
System.Runtime
Der System.Runtime
Meter meldet Messungen von GC, JIT, AssemblyLoader, Threadpool und Ausnahmebehandlungsabschnitten der .NET-Laufzeit sowie einige CPU- und Speichermetriken aus dem Betriebssystem. Diese Metriken sind automatisch für alle .NET-Apps verfügbar.
Metrik: dotnet.process.cpu.time
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.process.cpu.time |
Leistungsindikator | s |
Cpu-Zeit, die vom Prozess verwendet wird. |
attribute | type | Beschreibung | Beispiele | Anwesenheit |
---|---|---|---|---|
cpu.mode |
Zeichenfolge | Der Modus der CPU. | user ; system |
Always |
Diese Metrik meldet dieselben Werte wie der Zugriff auf die Prozessorzeiteigenschaften System.Diagnostics.Process für den aktuellen Prozess. Der system
Modus entspricht PrivilegedProcessorTime und user
der Modus entspricht UserProcessorTime
Verfügbar ab: .NET 9.0.
Metrik: dotnet.process.memory.working_set
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.process.memory.working_set |
UpDownCounter | By |
Die Anzahl der Bytes des physischen Speichers, die dem Prozesskontext zugeordnet sind. |
Diese Metrik meldet dieselben Werte wie die aufrufende Environment.WorkingSet Eigenschaft.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.gc.collections
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.gc.collections |
Leistungsindikator | {collection} |
Die Anzahl der Garbage Collections, die seit dem Start des Prozesses aufgetreten sind. |
attribute | type | Beschreibung | Beispiele | Anwesenheit |
---|---|---|---|---|
dotnet.gc.heap.generation |
Zeichenfolge | Name der maximal verwalteten Heap-Generation, die gesammelt wird. | gen0 ; gen1 ; gen2 |
Always |
.NET GC ist ein generationaler Garbage Collector. Jedes Mal, wenn der Garbage Collector ausgeführt wird, verwendet er Heuristiken, um eine maximale Generation auszuwählen und sammelt dann Objekte in allen Generationen bis zum ausgewählten Maximum. Eine Auflistung sammelt z. B gen1
. alle Objekte in den Generationen 0 und 1. Eine gen2
Auflistung sammelt alle Objekte in den Generationen 0, 1 und 2. Weitere Informationen zur .NET GC- und generierungs-Garbage Collection finden Sie im .NET Garbage Collection Guide.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.gc.heap.total_allocated
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.gc.heap.total_allocated |
Leistungsindikator | By |
Die ungefähre Anzahl der Bytes, die dem verwalteten GC-Heap zugeordnet sind, seit dem Prozess gestartet wurde. Der zurückgegebene Wert enthält keine systemeigenen Zuordnungen. |
Diese Metrik meldet dieselben Werte wie das Aufrufen GC.GetTotalAllocatedBytes. Weitere Informationen zur .NET GC finden Sie im .NET Garbage Collection Guide.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.gc.last_collection.memory.committed_size
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.gc.last_collection.memory.committed_size |
UpDownCounter | By |
Die Menge des zugesicherten virtuellen Speichers, der von .NET GC verwendet wird, wie bei der neuesten Garbage Collection beobachtet. |
Diese Metrik meldet dieselben Werte wie das Aufrufen GCMemoryInfo.TotalCommittedBytes. Der zugesicherte virtuelle Speicher ist möglicherweise größer als die Heap-Größe, da er sowohl Speicher zum Speichern vorhandener Objekte (der Heap-Größe) als auch einen zusätzlichen Speicher enthält, der für die Verarbeitung neu zugeordneter Objekte in Der Zukunft bereit ist. Weitere Informationen zur .NET GC finden Sie im .NET Garbage Collection Guide.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.gc.last_collection.heap.size
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.gc.last_collection.heap.size |
UpDownCounter | By |
Die verwaltete GC-Heapgröße (einschließlich Fragmentierung), wie bei der neuesten Garbage Collection beobachtet. |
attribute | type | Beschreibung | Beispiele | Anwesenheit |
---|---|---|---|---|
dotnet.gc.heap.generation |
Zeichenfolge | Name der vom Garbage Collector verwalteten Heap-Generation. | gen0 ; gen1 ; gen2 ;loh ;poh |
Always |
Das .NET GC teilt den Heap in Generationen auf. Neben den standardmäßigen nummerierten Generationen setzt der GC auch einige Objekte in zwei spezielle Generationen:
- Der Heap (Large Object Heap, LOH) speichert .NET-Objekte, die im Vergleich zu typischen Objekten sehr groß sind.
- Der angeheftete Objekt heap (POH) speichert Objekte, die mithilfe der GC.AllocateArray API zugeordnet sind, wenn der
pinned
Parameter "true" ist.
Beide dieser besonderen Generationen werden bei gen2
GC Kollektionen gesammelt. Weitere Informationen zum .NET GC finden Sie im .NET Garbage Collection-Handbuch.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.gc.last_collection.heap.fragmentation.size
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.gc.last_collection.heap.fragmentation.size |
UpDownCounter | By |
Die Heapfragmentierung, wie bei der neuesten Garbage Collection beobachtet. |
Diese Metrik meldet dieselben Werte wie das Aufrufen GCGenerationInfo.FragmentationAfterBytes.
Wenn .NET-Objekte zugeordnet werden, werden sie zunächst zusammenhängend im Arbeitsspeicher angeordnet. Wenn jedoch einige dieser Objekte später von der GC gesammelt werden, erzeugt dies Lücken des nicht genutzten Speichers zwischen den verbleibenden Liveobjekten. Diese Lücken stellen den Teil des GC-Heaps dar, der derzeit nicht zum Speichern von Objekten verwendet wird, häufig als "Fragmentierung" bezeichnet. Die GC kann die Fragmentierungsbytes in Zukunft für neue Objektzuordnungen wiederverwenden, wenn die Objektgröße klein genug ist, um in einen der Lücken zu passen. Die GC kann auch eine spezielle komprimierende Garbage Collection durchführen, die verbleibende Liveobjekte nebeneinander verschiebt, solange die Objekte nicht angeheftet wurden.
Weitere Informationen zur Funktionsweise von .NET GC, zur Analyse der GC-Leistung und zur Rollefragmentierung finden Sie unter .NET-Speicherleistungsanalyse.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.gc.pause.time
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.gc.pause.time |
Leistungsindikator | s |
Die Gesamtdauer, die seit dem Start des Prozesses in GC angehalten wurde. |
Diese Metrik meldet dieselben Werte wie das Aufrufen GC.GetTotalPauseDuration().
Jedes Mal, wenn .NET GC eine Auflistung ausführt, muss sie alle Threads, die verwalteten Code ausführen, kurz anhalten, um zu bestimmen, auf welche Objekte immer noch verwiesen wird. Diese Metrik meldet die Summe all dieser Pausenzeiten seit beginn des Prozesses. Sie können diese Metrik verwenden, um zu bestimmen, welcher Anteil von Zeitthreads für GC angehalten wird, im Vergleich zu der Zeit, in der sie verwalteten Code ausführen können.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.jit.compiled_il.size
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.jit.compiled_il.size |
Leistungsindikator | By |
Anzahl der Bytes der Zwischensprache, die seit dem Start des Prozesses kompiliert wurden. |
Diese Metrik meldet dieselben Werte wie das Aufrufen JitInfo.GetCompiledILBytes.
Wenn Sie eine .NET-App erstellen, wird verwalteter Code zunächst aus einer allgemeinen Sprache wie C#, VB oder F# in Zwischensprache (IL) kompiliert. Wenn das Programm ausgeführt wird, konvertiert der .NET just-in-time (JIT)-Compiler die IL in Computercode.
Da die JIT-Kompilierung beim ersten Ausführen einer Methode auftritt, tritt die meisten JIT-Kompilierung während des Anwendungsstarts auf. Durch die Verringerung der Anzahl der kompilierten IL-Dateien kann die Startzeit der Anwendung verbessert werden.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.jit.compiled_methods
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.jit.compiled_methods |
Leistungsindikator | {method} |
Die Häufigkeit, mit der der JIT-Compiler (re)kompilierte Methoden seit dem Start des Prozesses kompiliert wurde. |
Diese Metrik meldet dieselben Werte wie das Aufrufen JitInfo.GetCompiledMethodCount.
Wenn Sie eine .NET-App erstellen, wird verwalteter Code zunächst aus einer allgemeinen Sprache wie C#, VB oder F# in Zwischensprache (IL) kompiliert. Wenn das Programm ausgeführt wird, konvertiert der .NET just-in-time (JIT)-Compiler die IL in Computercode.
Da die JIT-Kompilierung beim ersten Ausführen einer Methode auftritt, tritt die meisten JIT-Kompilierung während des Anwendungsstarts auf. Das Verringern der Anzahl der Methoden, die JIT kompiliert werden müssen, kann die Startzeit der Anwendung verbessern.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.jit.compilation.time
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.jit.compilation.time |
Leistungsindikator | s |
Die Zeitspanne, die der JIT-Compiler zum Kompilieren von Methoden seit dem Start des Prozesses aufgewendet hat. |
Diese Metrik meldet dieselben Werte wie das Aufrufen JitInfo.GetCompilationTime.
Wenn Sie eine .NET-App erstellen, wird verwalteter Code zunächst aus einer allgemeinen Sprache wie C#, VB oder F# in Zwischensprache (IL) kompiliert. Wenn das Programm ausgeführt wird, konvertiert der .NET just-in-time (JIT)-Compiler die IL in Computercode.
Da die JIT-Kompilierung beim ersten Ausführen einer Methode auftritt, tritt die meisten JIT-Kompilierung während des Anwendungsstarts auf. Durch die Reduzierung der zeitaufwendigen JIT-Kompilierung kann die Startzeit der Anwendung verbessert werden.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.thread_pool.thread.count
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.thread_pool.thread.count |
UpDownCounter | {thread} |
Die Anzahl der threadpoolthreads, die derzeit vorhanden sind. |
Diese Metrik meldet dieselben Werte wie das Aufrufen ThreadPool.ThreadCount.
.NET verwendet einen Threadpool , um Arbeitsaufgaben in anderen Threads zu planen. Diese Metrik stellt die Anzahl der Arbeitsthreads bereit, die derzeit von diesem Threadpool verwaltet werden.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.thread_pool.work_item.count
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.thread_pool.work_item.count |
Leistungsindikator | {work_item} |
Die Anzahl der Arbeitsaufgaben, die der Threadpool seit dem Start des Prozesses abgeschlossen hat. |
Diese Metrik meldet dieselben Werte wie das Aufrufen ThreadPool.CompletedWorkItemCount.
.NET verwendet einen Threadpool , um Arbeitsaufgaben in anderen Threads zu planen. Diese Metrik stellt die Anzahl der Arbeitsaufgaben bereit, die von den Threadpoolthreads ausgeführt wurden.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.thread_pool.queue.length
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.thread_pool.queue.length |
UpDownCounter | {work_item} |
Die Anzahl der Arbeitsaufgaben, die derzeit vom Threadpool verarbeitet werden sollen. |
Diese Metrik meldet dieselben Werte wie das Aufrufen ThreadPool.PendingWorkItemCount.
.NET verwendet einen Threadpool , um Arbeitsaufgaben in anderen Threads zu planen. Diese Metrik stellt die Anzahl der Arbeitsaufgaben bereit, die derzeit von einem der Threadpoolthreads in die Warteschlange gestellt werden.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.monitor.lock_contentions
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.monitor.lock_contentions |
Leistungsindikator | {contention} |
Die Anzahl der Fehler beim Versuch, eine Monitorsperre seit dem Start des Prozesses abzurufen. |
Diese Metrik meldet dieselben Werte wie das Aufrufen Monitor.LockContentionCount.
.NET unterstützt die Verwendung eines beliebigen verwalteten Objekts als Sperre, entweder mit APIs wie Monitor.Enter z. B. oder mit der Lock-Anweisung. Wenn ein Thread bereits eine Sperre enthält, während ein zweiter Thread versucht, ihn abzurufen, wird dies als Sperrverknügung bezeichnet.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.timer.count
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.timer.count |
UpDownCounter | {timer} |
Die Anzahl der Zeitgeberinstanzen, die derzeit aktiv sind. |
Diese Metrik meldet dieselben Werte wie das Aufrufen Timer.ActiveCount.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.assembly.count
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.assembly.count |
UpDownCounter | {assembly} |
Die Anzahl der .NET-Assemblys, die derzeit geladen sind. |
Diese Metrik meldet die gleichen Werte wie das Aufrufen AppDomain.GetAssemblies() und überprüfen dann die Länge des zurückgegebenen Arrays.
Verfügbar ab: .NET 9.0.
Metrik: dotnet.exceptions
Name | Instrument Typ | Einheit (UCUM) | Beschreibung |
---|---|---|---|
dotnet.exceptions |
Leistungsindikator | {exception} |
Die Anzahl der Ausnahmen, die in verwaltetem Code ausgelöst wurden. |
attribute | type | Beschreibung | Beispiele | Anwesenheit |
---|---|---|---|---|
error.type |
Zeichenfolge | Der Ausnahmetyp, der ausgelöst wurde. | System.OperationCanceledException ; Contoso.MyException |
Required |
Diese Metrik meldet dieselben Werte wie das Zählen von Aufrufen des Ereignisses AppDomain.FirstChanceException .
Verfügbar ab: .NET 9.0.