System.Diagnostics Namespace

Provides classes that allow you to interact with system processes, event logs, and performance counters.

Classes

Activity	Represents an operation with context to be used for logging.
ActivityListener	Allows listening to the start and stop activity events and gives the opportunity to decide creating an activity for sampling scenarios.
ActivitySource	Provides APIs to create and start Activity objects and to register ActivityListener objects to listen to the Activity events.
ActivityTagsCollection	ActivityTagsCollection is a collection class used to store tracing tags. This collection will be used with classes like ActivityEvent and ActivityLink. This collection behaves as follows: The collection items will be ordered according to how they are added. Don't allow duplication of items with the same key. When using the indexer to store an item in the collection: If the item has a key that previously existed in the collection and the value is null, the collection item matching the key will be removed from the collection. If the item has a key that previously existed in the collection and the value is not null, the new item value will replace the old value stored in the collection. Otherwise, the item will be added to the collection. Add method will add a new item to the collection if an item doesn't already exist with the same key. Otherwise, it will throw an exception.
BooleanSwitch	Provides a simple on/off switch that controls debugging and tracing output.
ConditionalAttribute	Indicates to compilers that a method call or attribute should be ignored unless a specified conditional compilation symbol is defined.
ConsoleTraceListener	Directs tracing or debugging output to either the standard output or the standard error stream.
CorrelationManager	Correlates traces that are part of a logical transaction.
DataReceivedEventArgs	Provides data for the OutputDataReceived and ErrorDataReceived events.
Debug	Provides a set of methods and properties that help debug your code.
DebuggableAttribute	Modifies code generation for runtime just-in-time (JIT) debugging. This class cannot be inherited.
Debugger	Enables communication with a debugger. This class cannot be inherited.
DebuggerBrowsableAttribute	Determines if and how a member is displayed in the debugger variable windows. This class cannot be inherited.
DebuggerDisableUserUnhandledExceptionsAttribute	If a .NET Debugger is attached that supports the BreakForUserUnhandledException(Exception) API, the debugger won't break on user-unhandled exceptions when the exception is caught by a method with this attribute, unless BreakForUserUnhandledException(Exception) is called.
DebuggerDisplayAttribute	Determines how a class or field is displayed in the debugger variable windows.
DebuggerHiddenAttribute	Specifies the DebuggerHiddenAttribute. This class cannot be inherited.
DebuggerNonUserCodeAttribute	Identifies a type or member that is not part of the user code for an application.
DebuggerStepperBoundaryAttribute	Indicates the code following the attribute is to be executed in run, not step, mode.
DebuggerStepThroughAttribute	Instructs the debugger to step through the code instead of stepping into the code. This class cannot be inherited.
DebuggerTypeProxyAttribute	Specifies the display proxy for a type.
DebuggerVisualizerAttribute	Specifies that the type has a visualizer. This class cannot be inherited.
DefaultTraceListener	Provides the default output methods and behavior for tracing.
DelimitedListTraceListener	Directs tracing or debugging output to a text writer, such as a stream writer, or to a stream, such as a file stream.
DiagnosticListener	Provides an implementation of the abstract DiagnosticSource class that represents a named place to which a source sends its information (events).
DiagnosticMethodInfo	Represents diagnostic information about a method. Information provided by this class is similar to information provided by MethodBase but it's meant for logging and tracing purposes.
DiagnosticSource	An abstract class that allows code to be instrumented for production-time logging of rich data payloads for consumption within the process that was instrumented.
DistributedContextPropagator	An implementation of DistributedContextPropagator determines if and how distributed context information is encoded and decoded as it traverses the network. The encoding can be transported over any network protocol that supports string key-value pairs. For example, when using HTTP, each key-value pair is an HTTP header. DistributedContextPropagator injects values into and extracts values from carriers as string key-value pairs.
EventTypeFilter	Indicates whether a listener should trace based on the event type.
FileVersionInfo	Provides version information for a physical file on disk.
InitializingSwitchEventArgs	Provides data for the Switch.Initializing event.
InitializingTraceSourceEventArgs	Provides data for the TraceSource.Initializing event.
MonitoringDescriptionAttribute	Specifies a description for a property or event.
Process	Provides access to local and remote processes and enables you to start and stop local system processes.
ProcessModule	Represents a .dll or .exe file that is loaded into a particular process.
ProcessModuleCollection	Provides a strongly typed collection of ProcessModule objects.
ProcessStartInfo	Specifies a set of values that are used when you start a process.
ProcessThread	Represents an operating system process thread.
ProcessThreadCollection	Provides a strongly typed collection of ProcessThread objects.
SourceFilter	Indicates whether a listener should trace a message based on the source of a trace.
SourceSwitch	Provides a multilevel switch to control tracing and debug output without recompiling your code.
StackFrame	Provides information about a StackFrame, which represents a function call on the call stack for the current thread.
StackFrameExtensions	Provides extension methods for the StackFrame class, which represents a function call on the call stack for the current thread.
StackTrace	Represents a stack trace, which is an ordered collection of one or more stack frames.
StackTraceHiddenAttribute	Types and Methods attributed with StackTraceHidden will be omitted from the stack trace text shown in StackTrace.ToString() and Exception.StackTrace
Stopwatch	Provides a set of methods and properties that you can use to accurately measure elapsed time.
Switch	Provides an abstract base class to create new debugging and tracing switches.
SwitchAttribute	Identifies a switch used in an assembly, class, or member.
SwitchLevelAttribute	Identifies the level type for a switch.
TextWriterTraceListener	Directs tracing or debugging output to a TextWriter or to a Stream, such as FileStream.
Trace	Provides a set of methods and properties that help you trace the execution of your code. This class cannot be inherited.
TraceEventCache	Provides trace event data specific to a thread and a process.
TraceFilter	Provides the base class for trace filter implementations.
TraceListener	Provides the abstract base class for the listeners who monitor trace and debug output.
TraceListenerCollection	Provides a thread-safe list of TraceListener objects.
TraceSource	Provides a set of methods and properties that enable applications to trace the execution of code and associate trace messages with their source.
TraceSwitch	Provides a multilevel switch to control tracing and debug output without recompiling your code.
UnreachableException	The exception that is thrown when the program executes an instruction that was thought to be unreachable.
XmlWriterTraceListener	Directs tracing or debugging output as XML-encoded data to a TextWriter or to a Stream, such as a FileStream.

Structs

Activity.Enumerator<T>	Enumerates the data stored on an Activity object.
ActivityChangedEventArgs	Provides data for the CurrentChanged event.
ActivityContext	A representation that conforms to the W3C TraceContext specification. It contains two identifiers: a TraceId and a SpanId, along with a set of common TraceFlags and system-specific TraceState values.
ActivityCreationOptions<T>	Encapsulates all the information that is sent to the activity listener, to make decisions about the creation of the activity instance, as well as its state. The possible generic type parameters are ActivityContext or String.
ActivityEvent	Represents an event containing a name and a timestamp, as well as an optional list of tags.
ActivityLink	Activities may be linked to zero or more activity context instances that are causally related. Activity links can point to activity contexts inside a single trace or across different traces. Activity links can be used to represent batched operations where an activity was initiated by multiple initiating activities, each representing a single incoming item being processed in the batch.
ActivitySpanId	Represents a SpanId formatted based on a W3C standard.
ActivityTagsCollection.Enumerator	Enumerates the elements of an ActivityTagsCollection.
ActivityTraceId	Represents a TraceId whose format is based on a W3C standard.
Debug.AssertInterpolatedStringHandler	Provides an interpolated string handler for Assert(Boolean) that only performs formatting if the assert fails.
Debug.WriteIfInterpolatedStringHandler	Provides an interpolated string handler for WriteIf(Boolean, String) and WriteLineIf(Boolean, Object) that only performs formatting if the condition applies.
TagList	Represents a list of tags that can be accessed by index. Provides methods to search, sort, and manipulate lists.
TagList.Enumerator	An enumerator for traversing a tag list collection.

Enums

ActivityIdFormat	Specifies the format of the Id property.
ActivityKind	Describes the relationship between the activity, its parents and its children in a trace.
ActivitySamplingResult	Enumeration values used by ActivityListener to indicate the amount of data to collect for the related Activity. Requesting more data causes a greater performance overhead.
ActivityStatusCode	Define the status code of the Activity which indicate the status of the instrumented operation.
ActivityTraceFlags	Specifies flags defined by the W3C standard that are associated with an activity.
DebuggableAttribute.DebuggingModes	Specifies the debugging mode for the just-in-time (JIT) compiler.
DebuggerBrowsableState	Provides display instructions for the debugger.
ProcessPriorityClass	Indicates the priority that the system associates with a process. This value, together with the priority value of each thread of the process, determines each thread's base priority level.
ProcessWindowStyle	Specified how a new window should appear when the system starts a process.
SourceLevels	Specifies the levels of trace messages filtered by the source switch and event type filter.
ThreadPriorityLevel	Specifies the priority level of a thread.
ThreadState	Specifies the current execution state of the thread.
ThreadWaitReason	Specifies the reason a thread is waiting.
TraceEventType	Identifies the type of event that has caused the trace.
TraceLevel	Specifies what messages to output for the Debug, Trace and TraceSwitch classes.
TraceOptions	Specifies trace data options to be written to the trace output.

Delegates

DataReceivedEventHandler	Represents the method that will handle the OutputDataReceived event or ErrorDataReceived event of a Process.
DistributedContextPropagator.PropagatorGetterCallback	Represents the callback method that's used in the extract methods of propagators. The callback is invoked to look up the value of a named field.
DistributedContextPropagator.PropagatorSetterCallback	Represents the callback method that's used in propagators' inject methods. This callback is invoked to set the value of a named field. Propagators may invoke it multiple times in order to set multiple fields.
ExceptionRecorder
SampleActivity<T>	A delegate that defines the signature of the ActivityListener callbacks used in the sampling process.

Remarks

• The EventLog component provides functionality to write to event logs, read event log entries, and create and delete event logs and event sources on the network. The EntryWrittenEventHandler provides a way to interact with event logs asynchronously. Supporting classes provide access to more detailed control, including: permission restrictions, the ability to specify event log types (which controls the type of default data that is written with an event log entry), and iterate through collections of event log entries. For more information about these tasks, see the EventLogPermission, EventLogEntryType, and EventLogEntryCollection classes.

• The Process class provides functionality to monitor system processes across the network, and to start and stop local system processes. In addition to retrieving lists of running processes (by specifying either the computer, the process name, or the process id) or viewing information about the process that currently has access to the processor, you can get detailed knowledge of process threads and modules both through the Process class itself, and by interacting with the ProcessThread and ProcessModule classes. The ProcessStartInfo class enables you to specify a variety of elements with which to start a new process, such as input, output, and error streams, working directories, and command line verbs and arguments. These give you fine control over the behavior of your processes. Other related classes let you specify window styles, process and thread priorities, and interact with collections of threads and modules.

• The PerformanceCounter class enables you to monitor system performance, while the PerformanceCounterCategory class provides a way to create new custom counters and categories. You can write to local custom counters and read from both local and remote counters (system as well as custom). You can sample counters using the PerformanceCounter class, and calculate results from successive performance counter samples using the CounterSample class. The CounterCreationData class enables you to create multiple counters in a category and specify their types. Other classes associated with the performance counter component provide access to collections of counters, counter permission, and counter types.

The System.Diagnostics namespace also provides classes that allow you to debug your application and to trace the execution of your code. For more information, see the Trace and Debug classes.