summaryrefslogtreecommitdiff
path: root/src/inc/1031/CORPerfMonSymbols.ini
diff options
context:
space:
mode:
Diffstat (limited to 'src/inc/1031/CORPerfMonSymbols.ini')
-rw-r--r--src/inc/1031/CORPerfMonSymbols.ini576
1 files changed, 576 insertions, 0 deletions
diff --git a/src/inc/1031/CORPerfMonSymbols.ini b/src/inc/1031/CORPerfMonSymbols.ini
new file mode 100644
index 0000000000..3c656ef037
--- /dev/null
+++ b/src/inc/1031/CORPerfMonSymbols.ini
@@ -0,0 +1,576 @@
+; Licensed to the .NET Foundation under one or more agreements.
+; The .NET Foundation licenses this file to you under the MIT license.
+; See the LICENSE file in the project root for more information.
+
+//------------------------------------------------------------------------
+// WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+//
+// AUTO GENERATED FILE. DO NOT EDIT. USE $/com99/src/profile/perfmonhelp
+//
+// WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+//------------------------------------------------------------------------
+
+// CORPerfMonSymbols.ini file
+[info]
+drivername=.NETFramework
+symbolfile=CORPerfMonSymbols.h
+
+[languages]
+009=English
+; 001=Arabic
+; 004=Chinese
+ 007=German
+; 00D=Hebrew
+; 011=Japanese
+; 012=Korean
+; 00A=Spanish
+; 00C=French
+; 010=Italian
+
+[objects]
+DotNetCLR_Memory_OBJECT_009_NAME=.NET CLR Memory
+DotNetCLR_Loading_OBJECT_009_NAME=.NET CLR Loading
+DotNetCLR_Jit_OBJECT_009_NAME=.NET CLR Jit
+DotNetCLR_Interop_OBJECT_009_NAME=.NET CLR Interop
+DotNetCLR_LocksAndThreads_OBJECT_009_NAME=.NET CLR LocksAndThreads
+DotNetCLR_Security_OBJECT_009_NAME=.NET CLR Security
+DotNetCLR_Remoting_OBJECT_009_NAME=.NET CLR Remoting
+DotNetCLR_Excep_OBJECT_009_NAME=.NET CLR Exceptions
+DotNetCLR_Memory_OBJECT_007_NAME=.NET CLR-Speicher
+DotNetCLR_Loading_OBJECT_007_NAME=.NET CLR-Ladevorgang
+DotNetCLR_Jit_OBJECT_007_NAME=.NET CLR-Jit
+DotNetCLR_Interop_OBJECT_007_NAME=.NET CLR-Interop
+DotNetCLR_LocksAndThreads_OBJECT_007_NAME=.NET CLR-Sperren und Threads
+DotNetCLR_Security_OBJECT_007_NAME=.NET CLR-Sicherheit
+DotNetCLR_Remoting_OBJECT_007_NAME=.NET CLR-Remote
+DotNetCLR_Excep_OBJECT_007_NAME=.NET CLR-Ausnahmen
+
+[text]
+DotNetCLR_Memory_OBJECT_009_NAME=.NET CLR Memory
+DotNetCLR_Memory_OBJECT_009_HELP=Counters for CLR Garbage Collected heap.
+
+GEN0_COLLECTIONS_COUNTER_009_NAME=# Gen 0 Collections
+GEN0_COLLECTIONS_COUNTER_009_HELP=This counter displays the number of times the generation 0 objects (youngest; most recently allocated) are garbage collected (Gen 0 GC) since the start of the application. Gen 0 GC occurs when the available memory in generation 0 is not sufficient to satisfy an allocation request. This counter is incremented at the end of a Gen 0 GC. Higher generation GCs include all lower generation GCs. This counter is explicitly incremented when a higher generation (Gen 1 or Gen 2) GC occurs. _Global_ counter value is not accurate and should be ignored. This counter displays the last observed value.
+
+GEN1_COLLECTIONS_COUNTER_009_NAME=# Gen 1 Collections
+GEN1_COLLECTIONS_COUNTER_009_HELP=This counter displays the number of times the generation 1 objects are garbage collected since the start of the application. The counter is incremented at the end of a Gen 1 GC. Higher generation GCs include all lower generation GCs. This counter is explicitly incremented when a higher generation (Gen 2) GC occurs. _Global_ counter value is not accurate and should be ignored. This counter displays the last observed value.
+
+GEN2_COLLECTIONS_COUNTER_009_NAME=# Gen 2 Collections
+GEN2_COLLECTIONS_COUNTER_009_HELP=This counter displays the number of times the generation 2 objects (older) are garbage collected since the start of the application. The counter is incremented at the end of a Gen 2 GC (also called full GC). _Global_ counter value is not accurate and should be ignored. This counter displays the last observed value.
+
+GEN0_BYTES_PROMOTED_COUNTER_009_NAME=Promoted Memory from Gen 0
+GEN0_BYTES_PROMOTED_COUNTER_009_HELP=This counter displays the bytes of memory that survive garbage collection (GC) and are promoted from generation 0 to generation 1; objects that are promoted just because they are waiting to be finalized are not included in this counter. This counter displays the value observed at the end of the last GC; its not a cumulative counter.
+
+GEN1_BYTES_PROMOTED_COUNTER_009_NAME=Promoted Memory from Gen 1
+GEN1_BYTES_PROMOTED_COUNTER_009_HELP=This counter displays the bytes of memory that survive garbage collection (GC) and are promoted from generation 1 to generation 2; objects that are promoted just because they are waiting to be finalized are not included in this counter. This counter displays the value observed at the end of the last GC; its not a cumulative counter. This counter is reset to 0 if the last GC was a Gen 0 GC only.
+
+GEN0_PROMOTION_RATE_009_NAME=Gen 0 Promoted Bytes/Sec
+GEN0_PROMOTION_RATE_009_HELP=This counter displays the bytes per second that are promoted from generation 0 (youngest) to generation 1; objects that are promoted just because they are waiting to be finalized are not included in this counter. Memory is promoted when it survives a garbage collection. This counter was designed as an indicator of relatively long-lived objects being created per sec. This counter displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+GEN1_PROMOTION_RATE_009_NAME=Gen 1 Promoted Bytes/Sec
+GEN1_PROMOTION_RATE_009_HELP=This counter displays the bytes per second that are promoted from generation 1 to generation 2 (oldest); objects that are promoted just because they are waiting to be finalized are not included in this counter. Memory is promoted when it survives a garbage collection. Nothing is promoted from generation 2 since it is the oldest. This counter was designed as an indicator of very long-lived objects being created per sec. This counter displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+GEN0_FINALIZATION_BYTES_PROMOTED_COUNTER_009_NAME=Promoted Finalization-Memory from Gen 0
+GEN0_FINALIZATION_BYTES_PROMOTED_COUNTER_009_HELP=This counter displays the bytes of memory that are promoted from generation 0 to generation 1 just because they are waiting to be finalized. This counter displays the value observed at the end of the last GC; its not a cumulative counter.
+
+GEN1_FINALIZATION_BYTES_PROMOTED_COUNTER_009_NAME=Promoted Finalization-Memory from Gen 1
+GEN1_FINALIZATION_BYTES_PROMOTED_COUNTER_009_HELP=This counter displays the bytes of memory that are promoted from generation 1 to generation 2 just because they are waiting to be finalized. This counter displays the value observed at the end of the last GC; its not a cumulative counter. This counter is reset to 0 if the last GC was a Gen 0 GC only.
+
+GEN0_HEAP_SIZE_COUNTER_009_NAME=Gen 0 heap size
+GEN0_HEAP_SIZE_COUNTER_009_HELP=This counter displays the maximum bytes that can be allocated in generation 0 (Gen 0); its does not indicate the current number of bytes allocated in Gen 0. A Gen 0 GC is triggered when the allocations since the last GC exceed this size. The Gen 0 size is tuned by the Garbage Collector and can change during the execution of the application. At the end of a Gen 0 collection the size of the Gen 0 heap is infact 0 bytes; this counter displays the size (in bytes) of allocations that would trigger the next Gen 0 GC. This counter is updated at the end of a GC; its not updated on every allocation.
+
+GEN1_HEAP_SIZE_COUNTER_009_NAME=Gen 1 heap size
+GEN1_HEAP_SIZE_COUNTER_009_HELP=This counter displays the current number of bytes in generation 1 (Gen 1); this counter does not display the maximum size of Gen 1. Objects are not directly allocated in this generation; they are promoted from previous Gen 0 GCs. This counter is updated at the end of a GC; its not updated on every allocation.
+
+GEN2_HEAP_SIZE_COUNTER_009_NAME=Gen 2 heap size
+GEN2_HEAP_SIZE_COUNTER_009_HELP=This counter displays the current number of bytes in generation 2 (Gen 2). Objects are not directly allocated in this generation; they are promoted from Gen 1 during previous Gen 1 GCs. This counter is updated at the end of a GC; its not updated on every allocation.
+
+LARGE_OBJECT_SIZE_COUNTER_009_NAME=Large Object Heap size
+LARGE_OBJECT_SIZE_COUNTER_009_HELP=This counter displays the current size of the Large Object Heap in bytes. Objects greater than 20 KBytes are treated as large objects by the Garbage Collector and are directly allocated in a special heap; they are not promoted through the generations. This counter is updated at the end of a GC; its not updated on every allocation.
+
+SURVIVE_FINALIZE_COUNTER_009_NAME=Finalization Survivors
+SURVIVE_FINALIZE_COUNTER_009_HELP=This counter displays the number of garbage collected objects that survive a collection because they are waiting to be finalized. If these objects hold references to other objects then those objects also survive but are not counted by this counter; the "Promoted Finalization-Memory from Gen 0" and "Promoted Finalization-Memory from Gen 1" counters represent all the memory that survived due to finalization. This counter is not a cumulative counter; its updated at the end of every GC with count of the survivors during that particular GC only. This counter was designed to indicate the extra overhead that the application might incur because of finalization.
+
+NUM_HANDLES_COUNTER_009_NAME=# GC Handles
+NUM_HANDLES_COUNTER_009_HELP=This counter displays the current number of GC Handles in use. GCHandles are handles to resources external to the CLR and the managed environment. Handles occupy small amounts of memory in the GCHeap but potentially expensive unmanaged resources.
+
+ALLOCATION_RATE_COUNTER_009_NAME=Allocated Bytes/sec
+ALLOCATION_RATE_COUNTER_009_HELP=This counter displays the rate of bytes per second allocated on the GC Heap. This counter is updated at the end of every GC; not at each allocation. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+INDUCED_GC_COUNTER_009_NAME=# Induced GC
+INDUCED_GC_COUNTER_009_HELP=This counter displays the peak number of times a garbage collection was performed because of an explicit call to GC.Collect. Its a good practice to let the GC tune the frequency of its collections.
+
+PER_TIME_IN_GC_COUNTER_009_NAME=% Time in GC
+PER_TIME_IN_GC_COUNTER_009_HELP=% Time in GC is the percentage of elapsed time that was spent in performing a garbage collection (GC) since the last GC cycle. This counter is usually an indicator of the work done by the Garbage Collector on behalf of the application to collect and compact memory. This counter is updated only at the end of every GC and the counter value reflects the last observed value; its not an average.
+
+PER_TIME_IN_GC_COUNTER_BASE_009_NAME=Not Displayed
+PER_TIME_IN_GC_COUNTER_BASE_009_HELP=Not Displayed.
+
+TOTAL_HEAP_SIZE_COUNTER_009_NAME=# Bytes in all Heaps
+TOTAL_HEAP_SIZE_COUNTER_009_HELP=This counter is the sum of four other counters; Gen 0 Heap Size; Gen 1 Heap Size; Gen 2 Heap Size and the Large Object Heap Size. This counter indicates the current memory allocated in bytes on the GC Heaps.
+
+TOTAL_COMMITTED_MEM_COUNTER_009_NAME=# Total committed Bytes
+TOTAL_COMMITTED_MEM_COUNTER_009_HELP=This counter displays the amount of virtual memory (in bytes) currently committed by the Garbage Collector. (Committed memory is the physical memory for which space has been reserved on the disk paging file).
+
+TOTAL_RESERVED_MEM_COUNTER_009_NAME=# Total reserved Bytes
+TOTAL_RESERVED_MEM_COUNTER_009_HELP=This counter displays the amount of virtual memory (in bytes) currently reserved by the Garbage Collector. (Reserved memory is the virtual memory space reserved for the application but no disk or main memory pages have been used.)
+
+GC_PINNED_OBJECTS_009_NAME=# of Pinned Objects
+GC_PINNED_OBJECTS_009_HELP=This counter displays the number of pinned objects encountered in the last GC. This counter tracks the pinned objects only in the heaps that were garbage collected e.g. a Gen 0 GC would cause enumeration of pinned objects in the generation 0 heap only. A pinned object is one that the Garbage Collector cannot move in memory.
+
+GC_SINKBLOCKS_009_NAME=# of Sink Blocks in use
+GC_SINKBLOCKS_009_HELP=This counter displays the current number of sync blocks in use. Sync blocks are per-object data structures allocated for storing synchronization information. Sync blocks hold weak references to managed objects and need to be scanned by the Garbage Collector. Sync blocks are not limited to storing synchronization information and can also store COM interop metadata. This counter was designed to indicate performance problems with heavy use of synchronization primitives.
+
+DotNetCLR_Loading_OBJECT_009_NAME=.NET CLR Loading
+DotNetCLR_Loading_OBJECT_009_HELP=Statistics for CLR Class Loader.
+
+LOADING_CLASSES_TOTAL_009_NAME=Total Classes Loaded
+LOADING_CLASSES_TOTAL_009_HELP=This counter displays the cumulative number of classes loaded in all Assemblies since the start of this application.
+
+LOADING_TIME_009_NAME=% Time Loading
+LOADING_TIME_009_HELP=Reserved for future use.
+
+LOADING_ASMSEARCHLEN_009_NAME=Assembly Search Length
+LOADING_ASMSEARCHLEN_009_HELP=Reserved for future use.
+
+LOADING_LOADFAILURES_TOTAL_009_NAME=Total # of Load Failures
+LOADING_LOADFAILURES_TOTAL_009_HELP=This counter displays the peak number of classes that have failed to load since the start of the application. These load failures could be due to many reasons like inadequate security or illegal format. Full details can be found in the profiling services help.
+
+LOADING_LOADFAILURES_INST_009_NAME=Rate of Load Failures
+LOADING_LOADFAILURES_INST_009_HELP=This counter displays the number of classes that failed to load per second. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval. These load failures could be due to many reasons like inadequate security or illegal format. Full details can be found in the profiling services help.
+
+LOADING_HEAPSIZE_009_NAME=Bytes in Loader Heap
+LOADING_HEAPSIZE_009_HELP=This counter displays the current size (in bytes) of the memory committed by the class loader across all AppDomains. (Committed memory is the physical memory for which space has been reserved on the disk paging file.)
+
+LOADING_APPDOMAINS_UNLOADED_TOTAL_009_NAME=Total appdomains unloaded
+LOADING_APPDOMAINS_UNLOADED_TOTAL_009_HELP=This counter displays the total number of AppDomains unloaded since the start of the application. If an AppDomain is loaded and unloaded multiple times this counter would count each of those unloads as separate.
+
+LOADING_APPDOMAINS_UNLOADED_INST_009_NAME=Rate of appdomains unloaded
+LOADING_APPDOMAINS_UNLOADED_INST_009_HELP=This counter displays the number of AppDomains unloaded per second. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+LOADING_CLASSES_CUR_009_NAME=Current Classes Loaded
+LOADING_CLASSES_CUR_009_HELP=This counter displays the current number of classes loaded in all Assemblies.
+
+LOADING_CLASSES_INST_009_NAME=Rate of Classes Loaded
+LOADING_CLASSES_INST_009_HELP=This counter displays the number of classes loaded per second in all Assemblies. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+LOADING_APPDOMAINS_CUR_009_NAME=Current appdomains
+LOADING_APPDOMAINS_CUR_009_HELP=This counter displays the current number of AppDomains loaded in this application. AppDomains (application domains) provide a secure and versatile unit of processing that the CLR can use to provide isolation between applications running in the same process.
+
+LOADING_APPDOMAINS_TOTAL_009_NAME=Total Appdomains
+LOADING_APPDOMAINS_TOTAL_009_HELP=This counter displays the peak number of AppDomains loaded since the start of this application. AppDomains (application domains) provide a secure and versatile unit of processing that the CLR can use to provide isolation between applications running in the same process.
+
+LOADING_APPDOMAINS_INST_009_NAME=Rate of appdomains
+LOADING_APPDOMAINS_INST_009_HELP=This counter displays the number of AppDomains loaded per second. AppDomains (application domains) provide a secure and versatile unit of processing that the CLR can use to provide isolation between applications running in the same process. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+LOADING_ASSEMBLIES_CUR_009_NAME=Current Assemblies
+LOADING_ASSEMBLIES_CUR_009_HELP=This counter displays the current number of Assemblies loaded across all AppDomains in this application. If the Assembly is loaded as domain-neutral from multiple AppDomains then this counter is incremented once only. Assemblies can be loaded as domain-neutral when their code can be shared by all AppDomains or they can be loaded as domain-specific when their code is private to the AppDomain.
+
+LOADING_ASSEMBLIES_TOTAL_009_NAME=Total Assemblies
+LOADING_ASSEMBLIES_TOTAL_009_HELP=This counter displays the total number of Assemblies loaded since the start of this application. If the Assembly is loaded as domain-neutral from multiple AppDomains then this counter is incremented once only. Assemblies can be loaded as domain-neutral when their code can be shared by all AppDomains or they can be loaded as domain-specific when their code is private to the AppDomain.
+
+LOADING_ASSEMBLIES_INST_009_NAME=Rate of Assemblies
+LOADING_ASSEMBLIES_INST_009_HELP=This counter displays the number of Assemblies loaded across all AppDomains per second. If the Assembly is loaded as domain-neutral from multiple AppDomains then this counter is incremented once only. Assemblies can be loaded as domain-neutral when their code can be shared by all AppDomains or they can be loaded as domain-specific when their code is private to the AppDomain. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+DotNetCLR_Jit_OBJECT_009_NAME=.NET CLR Jit
+DotNetCLR_Jit_OBJECT_009_HELP=Stats for CLR Jit.
+
+TOTAL_METHODS_JITTED_009_NAME=# of Methods Jitted
+TOTAL_METHODS_JITTED_009_HELP=This counter displays the total number of methods compiled Just-In-Time (JIT) by the CLR JIT compiler since the start of the application. This counter does not include the pre-jitted methods.
+
+JITTED_IL_CUR_009_NAME=# of IL Bytes Jitted
+JITTED_IL_CUR_009_HELP=This counter displays the total IL bytes jitted since the start of the application. This counter is exactly equivalent to the "Total # of IL Bytes Jitted" counter.
+
+JITTED_IL_TOTAL_009_NAME=Total # of IL Bytes Jitted
+JITTED_IL_TOTAL_009_HELP=This counter displays the total IL bytes jitted since the start of the application. This counter is exactly equivalent to the "# of IL Bytes Jitted" counter.
+
+JITTED_IL_INST_009_NAME=IL Bytes Jitted / sec
+JITTED_IL_INST_009_HELP=This counter displays the rate at which IL bytes are jitted per second. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+JIT_FAILURES_009_NAME=Standard Jit Failures
+JIT_FAILURES_009_HELP=This counter displays the peak number of methods the JIT compiler has failed to JIT since the start of the application. This failure can occur if the IL cannot be verified or if there was an internal error in the JIT compiler.
+
+TIME_IN_JIT_009_NAME=% Time in Jit
+TIME_IN_JIT_009_HELP=This counter displays the percentage of elapsed time spent in JIT compilation since the last JIT compilation phase. This counter is updated at the end of every JIT compilation phase. A JIT compilation phase is the phase when a method and its dependencies are being compiled.
+
+TIME_IN_JIT_BASE_009_NAME=Not Displayed
+TIME_IN_JIT_BASE_009_HELP=Not Displayed.
+
+DotNetCLR_Interop_OBJECT_009_NAME=.NET CLR Interop
+DotNetCLR_Interop_OBJECT_009_HELP=Stats for CLR interop.
+
+CURRENT_CCW_009_NAME=# of CCWs
+CURRENT_CCW_009_HELP=This counter displays the current number of Com-Callable-Wrappers (CCWs). A CCW is a proxy for the .NET managed object being referenced from unmanaged COM client(s). This counter was designed to indicate the number of managed objects being referenced by unmanaged COM code.
+
+CURRENT_STUBS_009_NAME=# of Stubs
+CURRENT_STUBS_009_HELP=This counter displays the current number of stubs created by the CLR. Stubs are responsible for marshalling arguments and return values from managed to unmanaged code and vice versa; during a COM Interop call or PInvoke call.
+
+NUM_MARSHALLING_009_NAME=# of marshalling
+NUM_MARSHALLING_009_HELP=This counter displays the total number of times arguments and return values have been marshaled from managed to unmanaged code and vice versa since the start of the application. This counter is not incremented if the stubs are inlined. (Stubs are responsible for marshalling arguments and return values). Stubs usually get inlined if the marshalling overhead is small.
+
+TOTAL_TLB_IMPORTS_009_NAME=# of TLB imports / sec
+TOTAL_TLB_IMPORTS_009_HELP=Reserved for future use.
+
+TOTAL_TLB_EXPORTS_009_NAME=# of TLB exports / sec
+TOTAL_TLB_EXPORTS_009_HELP=Reserved for future use.
+
+DotNetCLR_LocksAndThreads_OBJECT_009_NAME=.NET CLR LocksAndThreads
+DotNetCLR_LocksAndThreads_OBJECT_009_HELP=Stats for CLR Locks and Threads.
+
+CONTENTION_TOTAL_009_NAME=Total # of Contentions
+CONTENTION_TOTAL_009_HELP=This counter displays the total number of times threads in the CLR have attempted to acquire a managed lock unsuccessfully. Managed locks can be acquired in many ways; by the "lock" statement in C# or by calling System.Monitor.Enter or by using MethodImplOptions.Synchronized custom attribute.
+
+CONTENTION_INST_009_NAME=Contention Rate / sec
+CONTENTION_INST_009_HELP=Rate at which threads in the runtime attempt to acquire a managed lock unsuccessfully. Managed locks can be acquired in many ways; by the "lock" statement in C# or by calling System.Monitor.Enter or by using MethodImplOptions.Synchronized custom attribute.
+
+QUEUE_LENGTH_CUR_009_NAME=Current Queue Length
+QUEUE_LENGTH_CUR_009_HELP=This counter displays the total number of threads currently waiting to acquire some managed lock in the application. This counter is not an average over time; it displays the last observed value.
+
+QUEUE_LENGTH_TOTAL_009_NAME=Queue Length Peak
+QUEUE_LENGTH_TOTAL_009_HELP=This counter displays the total number of threads that waited to acquire some managed lock since the start of the application.
+
+QUEUE_LENGTH_INST_009_NAME=Queue Length / sec
+QUEUE_LENGTH_INST_009_HELP=This counter displays the number of threads per second waiting to acquire some lock in the application. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+CURRENT_LOGICAL_THREADS_009_NAME=# of current logical Threads
+CURRENT_LOGICAL_THREADS_009_HELP=This counter displays the number of current .NET thread objects in the application. A .NET thread object is created either by new System.Threading.Thread or when an unmanaged thread enters the managed environment. This counters maintains the count of both running and stopped threads. This counter is not an average over time; it just displays the last observed value.
+
+CURRENT_PHYSICAL_THREADS_009_NAME=# of current physical Threads
+CURRENT_PHYSICAL_THREADS_009_HELP=This counter displays the number of native OS threads created and owned by the CLR to act as underlying threads for .NET thread objects. This counters value does not include the threads used by the CLR in its internal operations; it is a subset of the threads in the OS process.
+
+RECOGNIZED_THREADS_CUR_009_NAME=# of current recognized threads
+RECOGNIZED_THREADS_CUR_009_HELP=This counter displays the number of threads that are currently recognized by the CLR; they have a corresponding .NET thread object associated with them. These threads are not created by the CLR; they are created outside the CLR but have since run inside the CLR at least once. Only unique threads are tracked; threads with same thread ID re-entering the CLR or recreated after thread exit are not counted twice.
+
+RECOGNIZED_THREADS_TOTAL_009_NAME=# of total recognized threads
+RECOGNIZED_THREADS_TOTAL_009_HELP=This counter displays the total number of threads that have been recognized by the CLR since the start of this application; these threads have a corresponding .NET thread object associated with them. These threads are not created by the CLR; they are created outside the CLR but have since run inside the CLR at least once. Only unique threads are tracked; threads with same thread ID re-entering the CLR or recreated after thread exit are not counted twice.
+
+RECOGNIZED_THREADS_INST_009_NAME=rate of recognized threads / sec
+RECOGNIZED_THREADS_INST_009_HELP=This counter displays the number of threads per second that have been recognized by the CLR; these threads have a corresponding .NET thread object associated with them. These threads are not created by the CLR; they are created outside the CLR but have since run inside the CLR at least once. Only unique threads are tracked; threads with same thread ID re-entering the CLR or recreated after thread exit are not counted twice. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+DotNetCLR_Security_OBJECT_009_NAME=.NET CLR Security
+DotNetCLR_Security_OBJECT_009_HELP=Stats for CLR Security.
+
+SECURITY_TOTALRTCHECKS_009_NAME=Total Runtime Checks
+SECURITY_TOTALRTCHECKS_009_HELP=This counter displays the total number of runtime Code Access Security (CAS) checks performed since the start of the application. Runtime CAS checks are performed when a caller makes a call to a callee demanding a particular permission; the runtime check is made on every call by the caller; the check is done by examining the current thread stack of the caller. This counter used together with "Stack Walk Depth" is indicative of performance penalty for security checks.
+
+SECURITY_TIMEAUTHORIZE_009_NAME=% Time Sig. Authenticating
+SECURITY_TIMEAUTHORIZE_009_HELP=Reserved for future use.
+
+SECURITY_LINKCHECKS_009_NAME=# Link Time Checks
+SECURITY_LINKCHECKS_009_HELP=This counter displays the total number of linktime Code Access Security (CAS) checks since the start of the application. Linktime CAS checks are performed when a caller makes a call to a callee demanding a particular permission at JIT compile time; linktime check is performed once per caller. This count is not indicative of serious performance issues; its indicative of the security system activity.
+
+SECURITY_TIMERTCHECKS_009_NAME=% Time in RT checks
+SECURITY_TIMERTCHECKS_009_HELP=This counter displays the percentage of elapsed time spent in performing runtime Code Access Security (CAS) checks since the last such check. CAS allows code to be trusted to varying degrees and enforces these varying levels of trust depending on code identity. This counter is updated at the end of a runtime security check; it represents the last observed value; its not an average.
+
+SECURITY_TIMERTCHECKS_BASE_009_NAME=Not Displayed
+SECURITY_TIMERTCHECKS_BASE_009_HELP=Not Displayed.
+
+SECURITY_DEPTHSECURITY_009_NAME=Stack Walk Depth
+SECURITY_DEPTHSECURITY_009_HELP=This counter displays the depth of the stack during that last runtime Code Access Security check. Runtime Code Access Security check is performed by crawling the stack. This counter is not an average; it just displays the last observed value.
+
+DotNetCLR_Remoting_OBJECT_009_NAME=.NET CLR Remoting
+DotNetCLR_Remoting_OBJECT_009_HELP=Stats for CLR Remoting.
+
+CONTEXT_REMOTECALLS_INST_009_NAME=Remote Calls/sec
+CONTEXT_REMOTECALLS_INST_009_HELP=This counter displays the number of remote procedure calls invoked per second. A remote procedure call is a call on any object outside the caller;s AppDomain. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+CONTEXT_CHANNELS_009_NAME=Channels
+CONTEXT_CHANNELS_009_HELP=This counter displays the total number of remoting channels registered across all AppDomains since the start of the application. Channels are used to transport messages to and from remote objects.
+
+CONTEXT_PROXIES_009_NAME=Context Proxies
+CONTEXT_PROXIES_009_HELP=This counter displays the total number of remoting proxy objects created in this process since the start of the process. Proxy object acts as a representative of the remote objects and ensures that all calls made on the proxy are forwarded to the correct remote object instance.
+
+CONTEXT_CLASSES_009_NAME=Context-Bound Classes Loaded
+CONTEXT_CLASSES_009_HELP=This counter displays the current number of context-bound classes loaded. Classes that can be bound to a context are called context-bound classes; context-bound classes are marked with Context Attributes which provide usage rules for synchronization; thread affinity; transactions etc.
+
+CONTEXT_OBJALLOC_009_NAME=Context-Bound Objects Alloc / sec
+CONTEXT_OBJALLOC_009_HELP=This counter displays the number of context-bound objects allocated per second. Instances of classes that can be bound to a context are called context-bound objects; context-bound classes are marked with Context Attributes which provide usage rules for synchronization; thread affinity; transactions etc. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+CONTEXT_CONTEXTS_009_NAME=Contexts
+CONTEXT_CONTEXTS_009_HELP=This counter displays the current number of remoting contexts in the application. A context is a boundary containing a collection of objects with the same usage rules like synchronization; thread affinity; transactions etc.
+
+CONTEXT_REMOTECALLS_TOTAL_009_NAME=Total Remote Calls
+CONTEXT_REMOTECALLS_TOTAL_009_HELP=This counter displays the total number of remote procedure calls invoked since the start of this application. A remote procedure call is a call on any object outside the caller;s AppDomain.
+
+DotNetCLR_Excep_OBJECT_009_NAME=.NET CLR Exceptions
+DotNetCLR_Excep_OBJECT_009_HELP=Runtime statistics on CLR exception handling.
+
+EXCEP_THROWN_TOTAL_009_NAME=# of Exceps Thrown
+EXCEP_THROWN_TOTAL_009_HELP=This counter displays the total number of exceptions thrown since the start of the application. These include both .NET exceptions and unmanaged exceptions that get converted into .NET exceptions e.g. null pointer reference exception in unmanaged code would get re-thrown in managed code as a .NET System.NullReferenceException; this counter includes both handled and unhandled exceptions. Exceptions that are re-thrown would get counted again. Exceptions should only occur in rare situations and not in the normal control flow of the program.
+
+EXCEP_THROWN_INST_009_NAME=# of Exceps Thrown / sec
+EXCEP_THROWN_INST_009_HELP=This counter displays the number of exceptions thrown per second. These include both .NET exceptions and unmanaged exceptions that get converted into .NET exceptions e.g. null pointer reference exception in unmanaged code would get re-thrown in managed code as a .NET System.NullReferenceException; this counter includes both handled and unhandled exceptions. Exceptions should only occur in rare situations and not in the normal control flow of the program; this counter was designed as an indicator of potential performance problems due to large (>100s) rate of exceptions thrown. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+TOTAL_EXCEP_FILTERS_RUN_009_NAME=# of Filters / sec
+TOTAL_EXCEP_FILTERS_RUN_009_HELP=This counter displays the number of .NET exception filters executed per second. An exception filter evaluates whether an exception should be handled or not. This counter tracks the rate of exception filters evaluated; irrespective of whether the exception was handled or not. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+TOTAL_EXCEP_FINALLYS_RUN_009_NAME=# of Finallys / sec
+TOTAL_EXCEP_FINALLYS_RUN_009_HELP=This counter displays the number of finally blocks executed per second. A finally block is guaranteed to be executed regardless of how the try block was exited. Only the finally blocks that are executed for an exception are counted; finally blocks on normal code paths are not counted by this counter. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+EXCEPT_STACK_DEPTH_009_NAME=Throw To Catch Depth / sec
+EXCEPT_STACK_DEPTH_009_HELP=This counter displays the number of stack frames traversed from the frame that threw the .NET exception to the frame that handled the exception per second. This counter resets to 0 when an exception handler is entered; so nested exceptions would show the handler to handler stack depth. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.
+
+DotNetCLR_Memory_OBJECT_007_NAME=.NET CLR-Speicher
+DotNetCLR_Memory_OBJECT_007_HELP=Zähler für CLR Garbage Collection Heap.
+
+GEN0_COLLECTIONS_COUNTER_007_NAME=Auflistungsanzahl der Generation 0
+GEN0_COLLECTIONS_COUNTER_007_HELP=Dieser Zähler zeigt an, wie oft die Objekte der Generation 0 (die zuletzt zugeordneten Objekte) seit dem Anwendungsstart in die Garbage collection (Gen 0 GC) aufgenommen wurden. Gen 0 GC tritt auf, wenn in Generation 0 nicht genügend Speicher verfügbar ist, um eine Zuordnungsanforderung auszuführen. Der Zähler wird am Ende einer Gen 0 GC erhöht. Die höheren GCs enthalten alle niedrigeren GCs. Der Zähler wird explizit erhöht, wenn eine höhere Generation (Gen 1 oder Gen 2) GC auftritt. Der Zählerwert _Global_ ist falsch und sollte ignoriert werden. Der Zähler zeigt den letzten Wert an.
+
+GEN1_COLLECTIONS_COUNTER_007_NAME=Auflistungsanzahl der Generation 1
+GEN1_COLLECTIONS_COUNTER_007_HELP=Dieser Zähler zeigt an, wie oft die Objekte der Generation 1 seit dem Anwendungsstart in die Garbage collection (Gen 0 GC) aufgenommen wurden. Der Zähler wird am Ende einer Gen 1 GC erhöht. Die höheren GCs enthalten alle niedrigeren GCs. Der Zähler wird explizit erhöht, wenn eine höhere Generation (Gen 2) GC auftritt. Der Zählerwert _Global_ ist falsch und sollte ignoriert werden. Der Zähler zeigt den letzten Wert an.
+
+GEN2_COLLECTIONS_COUNTER_007_NAME=Auflistungsanzahl der Generation 2
+GEN2_COLLECTIONS_COUNTER_007_HELP=Dieser Zähler zeigt an, wie oft die Objekte der Generation 2 (älter) seit dem Anwendungsstart in die Garbage collection (Gen 0 GC) aufgenommen wurden. Der Zähler wird am Ende einer Gen 2 GC (Vollständige GC) erhöht. Der Zählerwert _Global_ ist falsch und sollte ignoriert werden. Der Zähler zeigt den letzten Wert an.
+
+GEN0_BYTES_PROMOTED_COUNTER_007_NAME=Von Generation 0 avancierter Speicher
+GEN0_BYTES_PROMOTED_COUNTER_007_HELP=Dieser Zähler zeigt die Größe des Arbeitsspeichers in Bytes an, der nicht in die Garbage collection (GC) aufgenommen und von Generation 0 zu Generation 1 heraufgestuft wurde. Objekte, die nur heraufgestuft werden, da sie auf die Beendigung warten, sind nicht in diesem Zähler enthalten. Der Zähler zeigt den Wert am Ende der letzten GC an. Der Zähler ist nicht kumulativ.
+
+GEN1_BYTES_PROMOTED_COUNTER_007_NAME=Von Generation 1 avancierter Speicher
+GEN1_BYTES_PROMOTED_COUNTER_007_HELP=Dieser Zähler zeigt die Größe des Arbeitsspeichers in Bytes an, der nicht in die Garbage Collection (GC) aufgenommen und von Generation 1 zu Generation 2 heraufgestuft wurde. Objekte, die nur heraufgestuft werden, da sie auf die Beendigung warten, sind nicht in diesem Zähler enthalten. Der Zähler zeigt den Wert am Ende der letzten GC an. Der Zähler ist nicht kumulativ. Der Zähler wird auf 0 zurückgesetzt, wenn die letzte GC nur eine Gen 0 GC war.
+
+GEN0_PROMOTION_RATE_007_NAME=Von Generation 0 avancierte Bytes/Sek.
+GEN0_PROMOTION_RATE_007_HELP=Dieser Zähler zeigt die Bytes pro Sekunde an, die von Generation 0 (neueste) zu Generation 1 heraufgestuft werden. Objekte, die nur heraufgestuft werden, da sie auf die Beendigung warten, sind nicht in diesem Zähler enthalten. Der Speicher wird heraufgestuft, wenn er nicht in eine Garbage Collection aufgenommen wurde. Der Zähler wurde als Indikator von relativ langlebigen Objekten entworfen, die pro Sekunde erstellt werden. Der Zählen zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+GEN1_PROMOTION_RATE_007_NAME=Von Generation 1 avancierte Bytes/Sek.
+GEN1_PROMOTION_RATE_007_HELP=Dieser Zähler zeigt die Bytes pro Sekunde an, die von Generation 1 zu Generation 2 (älteste) heraufgestuft werden. Objekte, die nur heraufgestuft werden, da sie auf die Beendigung warten, sind nicht in diesem Zähler enthalten. Der Speicher wird heraufgestuft, wenn er nicht in eine Garbage Collection aufgenommen wurde. Von Generation 2 werden keine Objekte heraufgestuft, da sie die älteste Generation ist. Der Zähler wurde als Indikator von sehr langlebigen Objekten entworfen, die pro Sekunde erstellt werden. Der Zählen zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+GEN0_FINALIZATION_BYTES_PROMOTED_COUNTER_007_NAME=Von Gen 0 heraufgestufter Finalization-Speicher
+GEN0_FINALIZATION_BYTES_PROMOTED_COUNTER_007_HELP=Dieser Zähler zeigt die Größe des Arbeitsspeichers in Bytes an, von Generation 0 zu Generation 1 heraufgestuft wurde, da er auf die Beendigung wartet. Der Zähler zeigt den Wert am Ende der letzten GC an. Der Zähler ist nicht kumulativ.
+
+GEN1_FINALIZATION_BYTES_PROMOTED_COUNTER_007_NAME=Von Gen 1 heraufgestufter Finalization-Speicher
+GEN1_FINALIZATION_BYTES_PROMOTED_COUNTER_007_HELP=Dieser Zähler zeigt die Größe des Arbeitsspeichers in Bytes an, von Generation 1 zu Generation 2 heraufgestuft wurde, da er auf die Beendigung wartet. Der Zähler zeigt den Wert am Ende der letzten GC an. Der Zähler ist nicht kumulativ. Der Zähler wird auf 0 zurückgesetzt, wenn die letzte GC nur eine Gen 0 GC war.
+
+GEN0_HEAP_SIZE_COUNTER_007_NAME=Heapgröße der Generation 0
+GEN0_HEAP_SIZE_COUNTER_007_HELP=Dieser Zähler zeigt die maximale Anzahl der Bytes an, die in Generation 0 (Gen 0) zugeordnet werden können. Die aktuelle Anzahl der in Gen 0 zugeordneten Bytes wird nicht angezeigt. Eine Gen 0 GC wird ausgelöst, wenn die Zuordnung seit der letzten GC diesen Wert überschreitet size. Die Größe von Gen 0 wird vom Garbage Collector festgelegt und kann sich während dem Ausführen der Anwendung ändern. Am Ende einer Gen 0-Collection beträgt die Größe des Gen 0-Heaps 0 Bytes. Der Zähler zeigt die Größe (in Bytes) von Zuordnungen an, die die nächste Gen 0 GC auslösen. Der Zähler wird am Ende einer GC aktualisiert; nicht bei jeder Zuordnung.
+
+GEN1_HEAP_SIZE_COUNTER_007_NAME=Heapgröße der Generation 1
+GEN1_HEAP_SIZE_COUNTER_007_HELP=Dieser Zähler zeigt die aktuelle Anzahl der Bytes in Generation 1 (Gen 1) an. Die maximale Größe von Gen 1 wird nicht angezeigt. Objekte werden in dieser Generation nicht direkt zugeordnet, sondern von vorherigen Gen 0 GCs heraufgestuft. Der Zähler wird am Ende einer GC aktualisiert; nicht bei jeder Zuordnung.
+
+GEN2_HEAP_SIZE_COUNTER_007_NAME=Heapgröße der Generation 2
+GEN2_HEAP_SIZE_COUNTER_007_HELP=Dieser Zähler zeigt die aktuelle Anzahl der Bytes in Generation 2 (Gen 2) an. Objekte werden in dieser Generation nicht direkt zugeordnet, sondern von Gen 1 während vorherigenen Gen 1 GCs heraufgestuft. Der Zähler wird am Ende einer GC aktualisiert; nicht bei jeder Zuordnung.
+
+LARGE_OBJECT_SIZE_COUNTER_007_NAME=Objektheapgröße
+LARGE_OBJECT_SIZE_COUNTER_007_HELP=Dieser Zähler zeigt die aktuelle Größe des großen Objektheaps in Bytes an. Objekte, die größer als 20 KB sind, werden vom Garbage Collector als große Objekte behandelt und direkt in einem speziellen Heap zugeordnet. Sie werden nicht über Generationen heraufgestuft. Der Zähler wird am Ende einer GC aktualisiert; nicht bei jeder Zuordnung.
+
+SURVIVE_FINALIZE_COUNTER_007_NAME=Finalization Survivors
+SURVIVE_FINALIZE_COUNTER_007_HELP=Dieser Zähler zeigt die Anzahl der Objekt in der Garbage Collection an, die beibehalten werden, da sie auf die Beendigung warten. Wenn die Objekte Verweise auf andere Objekte enthalten, werden diese ebenfalls beibehalten, aber nicht gezählt. Die Zähler "Von Gen 0 heraufgestufter Finalization-Speicher" und "Von Gen 1 heraufgestufter Finalization-Speicher" stellen den gesamten Speicher dar, der beibehalten wurde. Der Zähler ist nicht kumulativ. Er wird am Ende einer GC mit den beibehaltenen Objekten aktualisiert. Der Zähler zeigt die zusätzlichen Objekte an, die die Anwendung aufgrund der Beendigung möglicherweise übernimmt.
+
+NUM_HANDLES_COUNTER_007_NAME=Anzahl der GC-Handle
+NUM_HANDLES_COUNTER_007_HELP=Dieser Zähler zeigt die aktuelle Anzahl der verwendeten G-Handles an. GCHandles sind Handles für externe CLR-Ressourecen und der verwalteten Umgebung. Die Handles belegeben nur wenig Arbeitsspeicher im GCHeap, aber wertvolle nicht verwaltete Ressourcen.
+
+ALLOCATION_RATE_COUNTER_007_NAME=Zugewiesene Bytes/Sek.
+ALLOCATION_RATE_COUNTER_007_HELP=Dieser Zähle zeigt die Rate der Bytes pro Sekunde an, die im GC-Heap zugeordnet werden. Der Zähler wird am Ende der GC aktualisiert, nicht bei jeder Zuordnung. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+INDUCED_GC_COUNTER_007_NAME=Anzahl der ausgelösten GC
+INDUCED_GC_COUNTER_007_HELP=Dieser Zähler zeigt an, wie oft die Garbage Collection aufgrund eines expliziten Aufrufs an GC.Collect maximal ausgeführt wurde. Die GC sollte die Frequenz ihrer Collections selbst festlegen.
+
+PER_TIME_IN_GC_COUNTER_007_NAME=GC-Zeitdauer in Prozent
+PER_TIME_IN_GC_COUNTER_007_HELP=Die GC-Zeitdauer in Prozent gibt die verstrichene Zeitdauer für eine Garbage Collection (GC) an, die seit dem letzten GC-Zyklus ausgeführt wurde. Der Zähler zeigt gewöhnlich an, wieviel Speicher vom Garbage Collector für die Anwendung gesammelt und komprimiert wurde. Der Zähler wird nur am Ende einer GC aktualisiert. Der Zählerwert reflektiert den letzten Wert; er gibt keinen Durchschnitt an.
+
+PER_TIME_IN_GC_COUNTER_BASE_007_NAME=Nicht angezeigt
+PER_TIME_IN_GC_COUNTER_BASE_007_HELP=Nicht angezeigt.
+
+TOTAL_HEAP_SIZE_COUNTER_007_NAME=Anzahl der Bytes in den Heaps
+TOTAL_HEAP_SIZE_COUNTER_007_HELP=Dieser Zähler stellt die Summe aus den vier anderen Zählern dar: Gen 0-Heapgröße, Gen 1-Heapgröße, Gen 2-Heapgröße und die Large Object-Heapgröße. Dieser Zähler zeigt den in den GC-Heaps zugeordneten Speicher in Bytes an.
+
+TOTAL_COMMITTED_MEM_COUNTER_007_NAME=Festgelegte Bytes insgesamt
+TOTAL_COMMITTED_MEM_COUNTER_007_HELP=Dieser Zähler zeigt den virtuellen Speicher in Bytes an, der vom Garbage Collector reserviert wurde. (Reservierter Arbeitsspeicher ist der physikalische Speicher, der in der Auslagerungsdatei des Datenträgers reserviert wird).
+
+TOTAL_RESERVED_MEM_COUNTER_007_NAME=Gesamtanzahl der reservierten Bytes
+TOTAL_RESERVED_MEM_COUNTER_007_HELP=Dieser Zähler zeigt den virtuellen Speicher in Bytes an, der vom Garbage Collector reserviert wird. (Reservierter Speicher ist der virtuelle Arbeitsspeicher, der für die Anwendung reserviert wird.)
+
+GC_PINNED_OBJECTS_007_NAME=Anzahl der fixierten Objekte
+GC_PINNED_OBJECTS_007_HELP=Dieser Zähler zeigt die Anzahl der fixierten Objekte in der letzten GC an. Der Zähler verfolgt die fixierten Objekte nur in den Heaps in der Garbage Collection. Eine Gen 0 GC verursacht z.B. die Enumeration der fixierten Objekte nur im Generation 0-Heap. Ein fixiertes Objekt kann nicht vom Garbage Collector in den Speicher verschoben werden.
+
+GC_SINKBLOCKS_007_NAME=Anzahl der verwendeten Sinkblöcke
+GC_SINKBLOCKS_007_HELP=Dieser Zähler zeigt die aktuelle Anzahl der verwendeten Synchronisierungsblöcke an. Synchronisierungsblöcke sind die Datenstrukturen pro Objekt, die zum Speichern der Synchronisierungsinformationen zugeordnet werden. Synchronisierungsblöcke enthalten Weak-Verweise auf verwaltete Objekte und müssen vom Garbage Collector überprüft werden. In Synchronisierungsblöcken können auch COM-Interop-Metadaten gespeichert werden. Der Zähler zeigt Leistungsprobleme an, die auftreten, wenn die Synchronisierungsprimitiven zu oft verwendet werden.
+
+DotNetCLR_Loading_OBJECT_007_NAME=.NET CLR-Ladevorgang
+DotNetCLR_Loading_OBJECT_007_HELP=Statistiken für das CLR-Klassenladeprogramm.
+
+LOADING_CLASSES_TOTAL_007_NAME=Gesamtanzahl der geladenen Klassen
+LOADING_CLASSES_TOTAL_007_HELP=Dieser Zähler zeigt die kumulative Anzahl der Klassen an, die in allen Assemblys seit dem Start der Anwendung geladen wurden.
+
+LOADING_TIME_007_NAME=Ladezeit in Prozent
+LOADING_TIME_007_HELP=Für die zukünftige Verwendung reserviert.
+
+LOADING_ASMSEARCHLEN_007_NAME=Assemblysuchlänge
+LOADING_ASMSEARCHLEN_007_HELP=Für die zukünftige Verwendung reserviert.
+
+LOADING_LOADFAILURES_TOTAL_007_NAME=Gesamtanzahl der Ladefehler
+LOADING_LOADFAILURES_TOTAL_007_HELP=Dieser Zähler zeigt die Höchstanzahl der Klassen an, die seit dem Start der Anwendung nicht geladen werden konnten. Möglicherweise ist die Sicherheit unangemessen oder das Format ist ungültig. Weitere Informationen finden Sie in der Hilfe.
+
+LOADING_LOADFAILURES_INST_007_NAME=Rate der Ladefehler
+LOADING_LOADFAILURES_INST_007_HELP=Dieser Zähler zeigt die Anzahl der Klassen pro Sekunde an, die nicht geladen werden konnten. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an. Die Ladefehler können mehrere Ursachen haben; z.B. unzureichende Sicherheit oder ein ungültiges Format. Weitere Informationen finden Sie in der Hilfe.
+
+LOADING_HEAPSIZE_007_NAME=Bytes im Lademodulheap
+LOADING_HEAPSIZE_007_HELP=Dieser Zähler zeigt die aktuelle Größe (in Bytes) des Arbeitsspeichers an, der vom Klassenladeprogramm in allen Anwendungsdomänen reserviert wurde. (Reservierter Arbeitsspeicher ist der physikalische Speicher, der in der Auslagerungsdatei des Datenträgers reserviert wird.)
+
+LOADING_APPDOMAINS_UNLOADED_TOTAL_007_NAME=Gesamtanzahl der entladenen Anwendungsdomänen
+LOADING_APPDOMAINS_UNLOADED_TOTAL_007_HELP=Dieser Zähler zeigt die Gesamtanzahl der Anwendungsdomänen an, die seit dem Anwendungsstart entladen wurden. Wenn eine Anwendungsdomäne mehrmals geladen und entladen wird, werden die Entladevorgänge einzeln gezählt.
+
+LOADING_APPDOMAINS_UNLOADED_INST_007_NAME=Rate der entladenen Anwendungsdomänen
+LOADING_APPDOMAINS_UNLOADED_INST_007_HELP=Dieser Zähler zeigt die Anzahl der Anwendungsdomänen an, die pro Sekunde entladen werden. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+LOADING_CLASSES_CUR_007_NAME=Aktuelle geladene Klassen
+LOADING_CLASSES_CUR_007_HELP=Dieser Zähler zeigt die aktuelle Anzahl der in allen Assemblys geladenen Klassen an.
+
+LOADING_CLASSES_INST_007_NAME=Rate der geladenen Klassen
+LOADING_CLASSES_INST_007_HELP=Dieser Zähler zeigt die Anzahl der pro Sekunden in allen Assemblys geladenen Klassen an. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+LOADING_APPDOMAINS_CUR_007_NAME=Aktuelle Anwendungsdomänen
+LOADING_APPDOMAINS_CUR_007_HELP=Dieser Zähler zeigt die aktuelle Anzahl der Anwendungsdomänen an, die in der Anwendung geladen sind. Anwendungsdomänen stellen eine sichere und vielseitige Verarbeitungseinheit bereit, mit der die CLR Anwendungen isolieren kann, die im gleichen Prozess ausgeführt werden.
+
+LOADING_APPDOMAINS_TOTAL_007_NAME=Anwendungsdomänen insgesamt
+LOADING_APPDOMAINS_TOTAL_007_HELP=Dieser Zähler zeigt die Höchstanzahl der Anwendungsdomänen an, die seit dem Starten Anwendung geladen wurden. Anwendungsdomänen stellen eine sichere und vielseitige Verarbeitungseinheit bereit, mit der die CLR Anwendungen isolieren kann, die im gleichen Prozess ausgeführt werden.
+
+LOADING_APPDOMAINS_INST_007_NAME=Rate der Anwendungsdomänen
+LOADING_APPDOMAINS_INST_007_HELP=Dieser Zähler zeigt die Anzahl der Anwendungsdomänen an, die pro Sekunde geladen werden. Anwendungsdomänen stellen eine sichere und vielseitige Verarbeitungseinheit bereit, mit der die CLR Anwendungen isolieren kann, die im gleichen Prozess ausgeführt werden. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+LOADING_ASSEMBLIES_CUR_007_NAME=Aktuelle Assemblys
+LOADING_ASSEMBLIES_CUR_007_HELP=Dieser Zähler zeigt die aktuelle Anzahl der Assemblys an, die in dieser Anwendung in allen Anwendungsdomänen geladen werden. Wenn die Assembly von mehreren Anwendungsdomänen als domänenneutral geladen wird, wird der Zähler nur einmal erhöht. Assemblys können als domänenneutral geladen werden, wenn ihr Code von allen Anwendungsdomänen gemeinsam genutzt werden kann. Assemblys können domänenspezifisch geladen werden, wenn ihr Code in der Anwendungsdomäne privat ist.
+
+LOADING_ASSEMBLIES_TOTAL_007_NAME=Assemblys insgesamt
+LOADING_ASSEMBLIES_TOTAL_007_HELP=Dieser Zähler zeigt die Gesamtanzahl der Assemblys an, die seit dem Start der Anwendung geladen wurden. Wenn die Assembly von mehreren Anwendungsdomänen als domänenneutral geladen wird, wird der Zähler nur einmal erhöht. Assemblys können als domänenneutral geladen werden, wenn ihr Code von allen Anwendungsdomänen gemeinsam genutzt werden kann. Assemblys können domänenspezifisch geladen werden, wenn ihr Code in der Anwendungsdomäne privat ist.
+
+LOADING_ASSEMBLIES_INST_007_NAME=Assemblyrate
+LOADING_ASSEMBLIES_INST_007_HELP=Dieser Zähler zeigt die Anzahl der Assemblys an, die pro Sekunden in allen Anwendungsdomänen geladen werden. Wenn die Assembly von mehreren Anwendungsdomänen als domänenneutral geladen wird, wird der Zähler nur einmal erhöht. Assemblys können als domänenneutral geladen werden, wenn ihr Code von allen Anwendungsdomänen gemeinsam genutzt werden kann. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+DotNetCLR_Jit_OBJECT_007_NAME=.NET CLR-Jit
+DotNetCLR_Jit_OBJECT_007_HELP=Statistik für CLR-Jit.
+
+TOTAL_METHODS_JITTED_007_NAME=Anzahl der mit JIT kompilierten Methoden
+TOTAL_METHODS_JITTED_007_HELP=Dieser Zähler zeigt die Gesamtanzahl der Methoden an, die vom CLR JIT-Compiler seit dem Start der Anwendung kompiliert wurden. Die nicht JIT-Methoden sind in diesem Zähler nicht enthalten.
+
+JITTED_IL_CUR_007_NAME=Anzahl der mit JIT kompilierten IL-Bytes
+JITTED_IL_CUR_007_HELP=Dieser Zeiger zeigt die Gesamtanzahl der mit JIT kompilierten IL-Bytes seit dem Start der Anwendung an. Dieser Zähler ist mit dem Zähler "Gesamtanzahl der mit JIT kompilierten IL-Bytes" identisch.
+
+JITTED_IL_TOTAL_007_NAME=Gesamtanzahl der mit JIT kompilierten IL-Bytes
+JITTED_IL_TOTAL_007_HELP=Dieser Zeiger zeigt die Gesamtanzahl der mit JIT kompilierten IL-Bytes seit dem Start der Anwendung an. Dieser Zähler ist mit dem Zähler "Anzahl der mit JIT kompilierten IL-Bytes" identisch.
+
+JITTED_IL_INST_007_NAME=Mit JIT kompilierte IL-Bytes/Sek.
+JITTED_IL_INST_007_HELP=Dieser Zähler zeigt die JIT-Rate pro Sekunde für IL-Bytes an. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+JIT_FAILURES_007_NAME=JIT-Standardfehler
+JIT_FAILURES_007_HELP=Dieser Zähler zeigt die Höchstanzahl der Methoden an, die seit dem Start der Anwendung nicht mit dem JIT-Compiler kompiliert werden konnten. Dieses Problem kann auftreten, wenn die IL nicht überprüft werden kann, oder wenn ein interner Fehler im JIT-Compiler aufgetreten ist.
+
+TIME_IN_JIT_007_NAME=JIT-Zeitdauer in Prozent
+TIME_IN_JIT_007_HELP=Dieser Zähler zeigt die verstrichene Zeit für die JIT-Kompilierung seit der letzten Kompilierungsphase in Prozent an. Der Zähler wird am Ende jeder JIT-Kompilierungsphase aktualisiert. Während einer JIT-Kompilierungsphase werden eine Methode und ihre Abhängigkeiten kompiliert.
+
+TIME_IN_JIT_BASE_007_NAME=Nicht angezeigt
+TIME_IN_JIT_BASE_007_HELP=Nicht angezeigt.
+
+DotNetCLR_Interop_OBJECT_007_NAME=.NET CLR-Interop
+DotNetCLR_Interop_OBJECT_007_HELP=Statistik für CLR-Interop.
+
+CURRENT_CCW_007_NAME=Anzahl der CCWs
+CURRENT_CCW_007_HELP=Dieser Zähler zeigt die aktuelle Anzahl der CCWs (Com-Callable-Wrappers) an. Ein CCW ist ein Proxy für das verwaltete .NET-Objekt, auf das von nicht verwalteten COM-Client verwiesen wird. Der Zähler zeigt die Anzahl der verwalteten Objekte an, auf die von nicht verwaltetem COM-Code verwiesen wird.
+
+CURRENT_STUBS_007_NAME=Anzahl der Stubs
+CURRENT_STUBS_007_HELP=Dieser Zähler zeigt die aktuelle Anzahl der Stubs an, die von der CLR erstellt wurden. Stubs sind für das Marshallen von Argumenten und Rückgabewerten zwischen verwaltetem und nicht verwaltetem Code während einem COM-Interopaufruf oder PInvoke-Aufruf verantwortlich.
+
+NUM_MARSHALLING_007_NAME=Anzahl der Marshallvorgänge
+NUM_MARSHALLING_007_HELP=Dieser Zähler zeigt an, wie oft Argumente und Rückgabewerte zwischen verwaltetem und nicht verwaltetem Code seit dem Start der Anwendung gemarshallt wurden. Der Zähler wird nicht erhöht, wenn die Stubs intern sind. (Stubs sind für das Marshallen von Argumenten und Rückgabewerten verantwortlich).
+
+TOTAL_TLB_IMPORTS_007_NAME=Anzahl der TLB-Importe/Sek.
+TOTAL_TLB_IMPORTS_007_HELP=Für die zukünftige Verwendung reserviert.
+
+TOTAL_TLB_EXPORTS_007_NAME=Anzahl der TLB-Exporte/Sek.
+TOTAL_TLB_EXPORTS_007_HELP=Für die zukünftige Verwendung reserviert.
+
+DotNetCLR_LocksAndThreads_OBJECT_007_NAME=.NET CLR-Sperren und Threads
+DotNetCLR_LocksAndThreads_OBJECT_007_HELP=Statistik für CLR-Sperren und Threads.
+
+CONTENTION_TOTAL_007_NAME=Gesamtanzahl der Konflikte
+CONTENTION_TOTAL_007_HELP=Dieser Zähler zeigt an, wie oft die Threads in der CLR versucht haben, erfolglos eine verwaltete Sperre abzurufen. Verwaltete Sperren können mit mehreren Methoden abgerufen werden. Durch die Anweisung "lock" in C#, durch Aufrufen von System.Monitor.Enter oder mit dem benutzerdefinierten Attribut MethodImplOptions.Synchronized.
+
+CONTENTION_INST_007_NAME=Konfliktrate/Sek.
+CONTENTION_INST_007_HELP=Rate mit der die Threads in der Runtime versuchen, erfolglos eine verwaltete Sperre abzurufen. Verwaltete Sperren können mit mehreren Methoden abgerufen werden. Durch die Anweisung "lock" in C#, durch Aufrufen von System.Monitor.Enter oder mit dem benutzerdefinierten Attribut MethodImplOptions.Synchronized.
+
+QUEUE_LENGTH_CUR_007_NAME=Aktuelle Warteschlangenlänge
+QUEUE_LENGTH_CUR_007_HELP=Dieser Zähler zeigt die Gesamtanzahl der Threads an, die auf eine verwaltete Sperrung in der Anwendung warten. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den letzten Wert an.
+
+QUEUE_LENGTH_TOTAL_007_NAME=Maximale Warteschlangenlänge
+QUEUE_LENGTH_TOTAL_007_HELP=Dieser Zähler zeigt die Gesamtanzahl der Threads an, die seit dem Start der Anwendung auf eine verwaltete Sperrung warten.
+
+QUEUE_LENGTH_INST_007_NAME=Warteschlangenlänge/Sek.
+QUEUE_LENGTH_INST_007_HELP=Dieser Zähler zeigt die Anzahl der Threads pro Sekunde an, die auf eine Sperrung der Anwendung warten. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+CURRENT_LOGICAL_THREADS_007_NAME=Anzahl der aktuellen logischen Threads
+CURRENT_LOGICAL_THREADS_007_HELP=Dieser Zähler zeigt die Anzahl der aktuellen .NET-Threadobjekte in der Anwendung an. Ein .NET-Threadobjekt wird von System.Threading.Thread erstellt, oder wenn ein nicht verwalteter Thread in die verwaltete Umgebung aufgenommen wird. Der Zähler verwaltet die Anzahl der ausgeführten und beendeten Threads. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den letzten Wert an.
+
+CURRENT_PHYSICAL_THREADS_007_NAME=Anzahl der aktuellen physikalischen Threads
+CURRENT_PHYSICAL_THREADS_007_HELP=Dieser Zähler zeigt die Anzahl der systemeigenen Betriebssystemthreads an, die von der CLR als untergeordnete .NET-Threadobjekte erstellt werden. Dieser Zählerwert enthält die Threads nicht, die von der CLR für interne Vorgänge verwendet werden. Er ist eine Teilmenge der Threads im Betriebssystemprozess.
+
+RECOGNIZED_THREADS_CUR_007_NAME=Anzahl der aktuellen erkannten Threads
+RECOGNIZED_THREADS_CUR_007_HELP=Dieser Zähler zeigt die Anzahl der Threads an, die von der CLR erkannt werden. Diesen Threads ist ein entsprechendes .NET-Threadobjekt zugewiesen. Die Threads werden außerhalb der CLR erstellt, aber wurden mindestens einmal in der CLR ausgeführt. Nur eindeutige Threads werden verfolgt. Threads mit der gleichen Thread-ID, die erneut in die CLR aufgenommen oder nach dem Beenden erstellt werden, werden nicht zweimal gezählt.
+
+RECOGNIZED_THREADS_TOTAL_007_NAME=Gesamtanzahl der erkannten Threads
+RECOGNIZED_THREADS_TOTAL_007_HELP=Dieser Zähler zeigt die Gesamtanzahl der Threads an, die von der CLR seit dem Start der Anwendung erkannt wurden. Diesen Threads ist ein entsprechendes .NET-Threadobjekt zugewiesen. Die Threads werden außerhalb der CLR erstellt, aber wurden mindestens einmal in der CLR ausgeführt. Nur eindeutige Threads werden verfolgt. Threads mit der gleichen Thread-ID, die erneut in die CLR aufgenommen oder nach dem Beenden erstellt werden, werden nicht zweimal gezählt.
+
+RECOGNIZED_THREADS_INST_007_NAME=Erkannte Threadrate/Sek.
+RECOGNIZED_THREADS_INST_007_HELP=Dieser Zähler zeigt die Anzahl der Threads pro Sekunde an, die von der CLR erkannt wurden. Diesen Threads ist ein entsprechendes .NET-Threadobjekt zugeordnet. Die Threads werden nicht von der CLR, sondern außerhalb der CLR erstellt, aber mindestens einmal in der CLR ausgeführt. Nur eindeutige Threads werden nachverfolgt; Threads mit der gleichen Thread-ID, die in der CLR wiederholt oder erneut erstellt werden, werden nicht zweimal gezählt. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+DotNetCLR_Security_OBJECT_007_NAME=.NET CLR-Sicherheit
+DotNetCLR_Security_OBJECT_007_HELP=Statistik für die CLR-Sicherheit.
+
+SECURITY_TOTALRTCHECKS_007_NAME=Laufzeitüberprüfungen insgesamt
+SECURITY_TOTALRTCHECKS_007_HELP=Dieser Zähler zeigt die Gesamtanzahl der CAS-Laufzeitüberprüfungen (Code Access Security) seit dem Start der Anwendung an. CAS-Laufzeitüberprüfungen werden ausgeführt wenn beim einem Aufruf eine bestimmte Berechtigung angefordert wird. Die Laufzeitüberprüfung wird für jeden Aufruf ausgeführt, indem der aktuelle Threadstapel des Aufrufers überprüft wird. Dieser Zähler gibt zusammen mit "Stapeltiefe" die Leistungseinbußen für Sicherheitsüberprüfungen an.
+
+SECURITY_TIMEAUTHORIZE_007_NAME=Zeit für die Signaturauthentifizierung in Prozent
+SECURITY_TIMEAUTHORIZE_007_HELP=Für die zukünftige Verwendung reserviert.
+
+SECURITY_LINKCHECKS_007_NAME=Anzahl der Verbindungszeitüberprüfungen
+SECURITY_LINKCHECKS_007_HELP=Dieser Zähler zeigt die Gesamtanzahl der CAS-Überprüfungen (Code Access Security) seit dem Anwendungsstart an. CAS-Linktimeüberprüfen werden ausgeführt, wenn eine bestimmte Berechtigung während der JIT-Kompilierung aufgerufen wird. Eine Linktimeüberprüfung wird nur einmal pro Aufrufer ausgeführt. Dieser Wert zeigt keine Leistungsprobleme an, nur die Sicherheitssystemaktivitäten.
+
+SECURITY_TIMERTCHECKS_007_NAME=Zeit für die RT-Überprüfungen in Prozent
+SECURITY_TIMERTCHECKS_007_HELP=Dieser Zähler zeigt den Zeitraum an, der seit der letzten CAS-Überprüfung (Code Access Security) verstrichen ist. CAS ermöglicht unterschiedliche Vertrauensebenen für den Code und erzwingt die Ebenen abhängig von der Codeidentität. Der Zähler wird am Ende einer Sicherheitsüberprüfung aktualisiert. Er zeigt keinen Durchschnittswert, sondern den letzten Wert an.
+
+SECURITY_TIMERTCHECKS_BASE_007_NAME=Nicht angezeigt
+SECURITY_TIMERTCHECKS_BASE_007_HELP=Nicht angezeigt.
+
+SECURITY_DEPTHSECURITY_007_NAME=Stapeltiefe
+SECURITY_DEPTHSECURITY_007_HELP=Dieser Zähler zeigt die Stapeltiefe während der letzten Überprüfung der Codezugriffssicherheit zur Laufzeit an. Beim Überprüfen Codezugriffssicherheit zur Laufzeit wird der Stapel durchsucht. Der Zähler gibt keinen Durchnittswert, sondern nur den letzten Wert an.
+
+DotNetCLR_Remoting_OBJECT_007_NAME=.NET CLR-Remote
+DotNetCLR_Remoting_OBJECT_007_HELP=Statistik für CLR-Remote.
+
+CONTEXT_REMOTECALLS_INST_007_NAME=Remoteaufrufe/Sek.
+CONTEXT_REMOTECALLS_INST_007_HELP=Dieser Zähler zeigt die Anzahl der Remoteprozeduraufrufe pro Sekunde an. Ein Remoteprozeduraufruf ist ein Aufruf eines Objekts außerhalb der Anwendungsdomäne des Aufrufers. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+CONTEXT_CHANNELS_007_NAME=Channel
+CONTEXT_CHANNELS_007_HELP=Dieser Zähler zeigt die Gesamtanzahl der Remotechannel in den Anwendungsdomänen an, die seit dem Start der Anwendung registriert wurden. Channel werden zum Übertragen von Nachrichten zwischen Remoteobjekten verwendet.
+
+CONTEXT_PROXIES_007_NAME=Kontextproxys
+CONTEXT_PROXIES_007_HELP=Dieser Zähler zeigt die Gesamtanzahl der Remoteproxyobjekte an, die in diesem Prozess seit dem Start der Anwendung erstellt wurden. Proxyobjekte stellen die Remoteobjekte dar und stellen sicher, dass alle Proxyaufrufe an die entsprechende Remoteobjektinstanz weitergeleitet werden.
+
+CONTEXT_CLASSES_007_NAME=Geladene kontextgebundene Klassen
+CONTEXT_CLASSES_007_HELP=Dieser Zähler zeigt die aktuelle Anzahl der kontextgebundenen geladenen Klassen an. Klassen, die an einen Kontext gebunden werden können, sind kontextgebundene Klassen. Kontextgebundene Klassen werden mit Kontextattributen für die Synchronisierung, Threadaffinität, Transaktionen, usw. markiert.
+
+CONTEXT_OBJALLOC_007_NAME=Kontextgebundene Objektzuordnung/Sek.
+CONTEXT_OBJALLOC_007_HELP=Dieser Zähler zeigt die Anzahl der kontextgebundenen Objekte an, die pro Sekunde zugeordnet werden. Instanzen von Klassen, die an einen Kontext gebunden werden können, sind kontextgebundene Objekte. Kontextgebundene Klassen werden mit Kontextattributen für die Synchronisation, Threadaffinität, Transaktionen, usw. markiert. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+CONTEXT_CONTEXTS_007_NAME=Kontext
+CONTEXT_CONTEXTS_007_HELP=Dieser Zähler zeigt die aktuelle Anzahl der Remotekontexte in der Anwendung an. Ein Kontext enthält eine Auflistung der Objekte mit den gleichen Syntaxregeln; z.B. Synchronisierung, Threadaffinität, Transaktionen, usw.
+
+CONTEXT_REMOTECALLS_TOTAL_007_NAME=Remoteaufrufe insgesamt
+CONTEXT_REMOTECALLS_TOTAL_007_HELP=Dieser Zähle zeigt die Gesamtanzahl der Remoteprozeduraufrufe an, die seit dem Start der Anwendung initialisiert wurden. Ein Remoteprozeduraufruf ist der Aufruf eines Objekts außerhalb der Anwendungsdomäne des Aufrufers.
+
+DotNetCLR_Excep_OBJECT_007_NAME=.NET CLR-Ausnahmen
+DotNetCLR_Excep_OBJECT_007_HELP=Laufzeitstatistik für die CLR-Ausnahmebehandlung.
+
+EXCEP_THROWN_TOTAL_007_NAME=Anzahl der ausgelösten Ausnahmen
+EXCEP_THROWN_TOTAL_007_HELP=Dieser Zähler zeigt die Gesamtanzahl der Ausnahmen an, die seit dem Start der Anwendung ausgelöst wurden. TDiese schließen .NET-Ausnahmen und nicht verwaltete Ausnahmen ein, die in .NET-Ausnahmen konvertiert werden; z.B. wird eine Nullzeigerverweis-Ausnahme in nicht verwaltetem Code in eine .NET System.NullReferenceException in verwaltetem Code konvertiert. Dieser Zähler enthält behandelte und unbehandelte Ausnahmen. Erneut ausgelöste Ausnahmen, werden wieder gezählt. Ausnahmen sollten nur selten und nicht im normalen Programmablauf auftreten.
+
+EXCEP_THROWN_INST_007_NAME=Anzahl der ausgelösten Ausnahmen/Sek.
+EXCEP_THROWN_INST_007_HELP=Dieser Zähler zeigt die Anzahl der Ausnahmen pro Sekunde an. Diese schließen .NET-Ausnahmen und nicht verwaltete Ausnahmen ein, die in .NET-Ausnahmen konvertiert werden; z.B. wird eine Nullzeigerverweis-Ausnahme in nicht verwaltetem Code in eine .NET System.NullReferenceException in verwaltetem Code konvertiert. Dieser Zähler enthält behandelte und unbehandelte Ausnahmen. Ausnahmen sollten nur selten und nicht im normalen Programmablauf auftreten. Der Zähler zeigt potentielle Leistungsprobleme an, die aufgrund einer großen Ausnahmerate auftreten. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+TOTAL_EXCEP_FILTERS_RUN_007_NAME=Anzahl der Filter/Sek.
+TOTAL_EXCEP_FILTERS_RUN_007_HELP=Dieser Zähler zeigt die Anzahl der .NET-Ausnahmefilter an, die pro Sekunde ausgeführt werden. Ein Ausnahmefilter wertet aus, ob eine Ausnahme behandelt werden soll. Der Zähler verfolgt die Rate der ausgewerteten Ausnahmefilter; ungeachtet davon, ob die Ausnahme behandelt wurde oder nicht. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+TOTAL_EXCEP_FINALLYS_RUN_007_NAME=Finallyanzahl/Sek.
+TOTAL_EXCEP_FINALLYS_RUN_007_HELP=Dieser Zähler zeigt die Anzahl der finally-Blöcke an, die pro Sekunde ausgeführt werden. Ein finally-Block wird ausgeführt, unabhängig davon, wie der try-Block beendet wurde. Nur die finally-Blöcke, die für eine Ausnahme ausgeführt werden, werden gezählt. finally-Blöcke in normalen Codepfaden werden nicht gezählt. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+
+EXCEPT_STACK_DEPTH_007_NAME=Throw To Catch Depth / sec
+EXCEPT_STACK_DEPTH_007_HELP=Dieser Zähler zeigt die Anzahl der Stapelrahmen an, die vom Rahmen durchlaufen werden, der die .NET-Ausnahme ausgelöst hat. Der Zähler wird auf 0 zurückgesetzt, wenn ein Ausnahmehandler eingegeben wird. Der Zähler bildet nicht den Mittelwert aus der Zeit, sondern zeigt den Unterschied zwischen den Werten in den letzten zwei Beispielen geteilt durch das Beispielintervall an.
+