Silverlight 5 WinRT

  public class BooleanSwitch
  : Switch
  public Boolean Enabled { get; set; }
  protected virtual void OnValueChanged();

public sealed class ConditionalAttribute public sealed class ConditionalAttribute
: Attribute, _Attribute : Attribute, _Attribute
public String ConditionString { get; } public String ConditionString { get; }

  public class ConsoleTraceListener
  : TextWriterTraceListener, IDisposable
  public virtual void Close();

  public class CorrelationManager
 
  public Guid ActivityId { get; set; }
  public Stack LogicalOperationStack { get; }
  public void StartLogicalOperation(Object operationId);
  public void StartLogicalOperation();
  public void StopLogicalOperation();

  public class CounterCreationData
 
  public String CounterHelp { get; set; }
  public String CounterName { get; set; }
  public PerformanceCounterType CounterType { get; set; }

  public class CounterCreationDataCollection
  : CollectionBase, IList, ICollection, IEnumerable
  public CounterCreationData Item { get; set; }
  public Int32 Add(CounterCreationData value);
  public void AddRange(CounterCreationData value);
  public void AddRange(CounterCreationDataCollection value);
  public Boolean Contains(CounterCreationData value);
  public void CopyTo(CounterCreationData array, Int32 index);
  public Int32 IndexOf(CounterCreationData value);
  public void Insert(Int32 index, CounterCreationData value);
  protected virtual void OnValidate(Object value);
  public virtual void Remove(CounterCreationData value);

  public sealed struct CounterSample
  : ValueType
  public Int64 BaseValue { get; }
  public Int64 CounterFrequency { get; }
  public Int64 CounterTimeStamp { get; }
  public PerformanceCounterType CounterType { get; }
  public Int64 RawValue { get; }
  public Int64 SystemFrequency { get; }
  public Int64 TimeStamp { get; }
  public Int64 TimeStamp100nSec { get; }
  static public Single Calculate(CounterSample counterSample);
  static public Single Calculate(CounterSample counterSample, CounterSample nextCounterSample);
  public virtual Boolean Equals(Object o);
  public Boolean Equals(CounterSample sample);
  public virtual Int32 GetHashCode();
  static public Boolean op_Equality(CounterSample a, CounterSample b);
  static public Boolean op_Inequality(CounterSample a, CounterSample b);

  public abstract sealed class CounterSampleCalculator
 
  static public Single ComputeCounterValue(CounterSample newSample);
  static public Single ComputeCounterValue(CounterSample oldSample, CounterSample newSample);

  public class DataReceivedEventArgs
  : EventArgs
  public String Data { get; }

  public sealed class DataReceivedEventHandler
  : MulticastDelegate, ICloneable, ISerializable
  public virtual IAsyncResult BeginInvoke(Object sender, DataReceivedEventArgs e, AsyncCallback callback, Object object);
  public virtual void EndInvoke(IAsyncResult result);
  public virtual void Invoke(Object sender, DataReceivedEventArgs e);

public abstract sealed class Debug public abstract sealed class Debug
  static public Boolean AutoFlush { get; set; }
  static public Int32 IndentLevel { get; set; }
  static public Int32 IndentSize { get; set; }
  static public TraceListenerCollection Listeners { get; }
  static public void Assert(Boolean condition, String message);
static public void Assert(Boolean condition); static public void Assert(Boolean condition);
static public void Assert(Boolean condition, String message); static public void Assert(Boolean condition, String message, String detailMessage);
static public void Assert(Boolean condition, String message, String detailMessage); static public void Assert(Boolean condition, String message, String detailMessageFormat, Object args);
static public void Assert(Boolean condition, String message, String detailMessageFormat, Object args);  
  static public void Close();
  static public void Fail(String message);
  static public void Fail(String message, String detailMessage);
  static public void Flush();
  static public void Indent();
  static public void Print(String message);
  static public void Print(String format, Object args);
  static public void Unindent();
  static public void Write(String message);
  static public void Write(Object value);
  static public void Write(String message, String category);
  static public void Write(Object value, String category);
  static public void WriteIf(Boolean condition, String message);
  static public void WriteIf(Boolean condition, Object value);
  static public void WriteIf(Boolean condition, String message, String category);
  static public void WriteIf(Boolean condition, Object value, String category);
static public void WriteLine(String message); static public void WriteLine(String message);
static public void WriteLine(Object value); static public void WriteLine(Object value);
  static public void WriteLine(String message, String category);
  static public void WriteLine(Object value, String category);
static public void WriteLine(String format, Object args); static public void WriteLine(String format, Object args);
  static public void WriteLineIf(Boolean condition, String message);
  static public void WriteLineIf(Boolean condition, Object value);
  static public void WriteLineIf(Boolean condition, String message, String category);

public sealed class DebuggableAttribute public sealed class DebuggableAttribute
: Attribute, _Attribute : Attribute, _Attribute
  public DebuggingModes DebuggingFlags { get; }
  public Boolean IsJITOptimizerDisabled { get; }

public sealed class Debugger public sealed class Debugger
static public Boolean IsAttached { get; } static public Boolean IsAttached { get; }
static public void Break(); static public void Break();
static public Boolean IsLogging(); static public Boolean IsLogging();
static public Boolean Launch(); static public Boolean Launch();
static public void Log(Int32 level, String category, String message); static public void Log(Int32 level, String category, String message);

public sealed class DebuggerBrowsableAttribute public sealed class DebuggerBrowsableAttribute
: Attribute, _Attribute : Attribute, _Attribute
public DebuggerBrowsableState State { get; } public DebuggerBrowsableState State { get; }

public sealed enum DebuggerBrowsableState public sealed enum DebuggerBrowsableState
: IComparable, IFormattable, IConvertible : IComparable, IFormattable, IConvertible
{ Never, Collapsed, RootHidden } { Never, Collapsed, RootHidden }

public sealed class DebuggerDisplayAttribute public sealed class DebuggerDisplayAttribute
: Attribute, _Attribute : Attribute, _Attribute
public String Name { get; set; } public String Name { get; set; }
public Type Target { get; set; } public Type Target { get; set; }
public String TargetTypeName { get; set; } public String TargetTypeName { get; set; }
public String Type { get; set; } public String Type { get; set; }
public String Value { get; } public String Value { get; }

public sealed class DebuggerHiddenAttribute public sealed class DebuggerHiddenAttribute
: Attribute, _Attribute : Attribute, _Attribute

public sealed class DebuggerNonUserCodeAttribute public sealed class DebuggerNonUserCodeAttribute
: Attribute, _Attribute : Attribute, _Attribute

  public sealed class DebuggerStepperBoundaryAttribute
  : Attribute, _Attribute

public sealed class DebuggerStepThroughAttribute public sealed class DebuggerStepThroughAttribute
: Attribute, _Attribute : Attribute, _Attribute

public sealed class DebuggerTypeProxyAttribute public sealed class DebuggerTypeProxyAttribute
: Attribute, _Attribute : Attribute, _Attribute
public String ProxyTypeName { get; } public String ProxyTypeName { get; }
public Type Target { get; set; } public Type Target { get; set; }
public String TargetTypeName { get; set; } public String TargetTypeName { get; set; }

sealed enum DebuggableAttribute+DebuggingModes  
: IComparable, IFormattable, IConvertible  
{ None, Default, DisableOptimizations, IgnoreSymbolStoreSequencePoints, EnableEditAndContinue }  

  public sealed class DebuggerVisualizerAttribute
  : Attribute, _Attribute
  public String Description { get; set; }
  public Type Target { get; set; }
  public String TargetTypeName { get; set; }
  public String VisualizerObjectSourceTypeName { get; }
  public String VisualizerTypeName { get; }

  sealed enum DebuggableAttribute
  : IComparable, IFormattable, IConvertible
  { None, Default, DisableOptimizations, IgnoreSymbolStoreSequencePoints, EnableEditAndContinue }

  public class DefaultTraceListener
  : TraceListener, IDisposable
  public Boolean AssertUiEnabled { get; set; }
  public String LogFileName { get; set; }
  public virtual void Fail(String message);
  public virtual void Fail(String message, String detailMessage);
  public virtual void Write(String message);
  public virtual void WriteLine(String message);

  public class DelimitedListTraceListener
  : TextWriterTraceListener, IDisposable
  public String Delimiter { get; set; }
  internal protected virtual String GetSupportedAttributes();
  public virtual void TraceData(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, Object data);
  public virtual void TraceData(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, Object data);
  public virtual void TraceEvent(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, String format, Object args);
  public virtual void TraceEvent(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, String message);

  public class DiagnosticsConfigurationHandler
  : IConfigurationSectionHandler
  public virtual Object Create(Object parent, Object configContext, XmlNode section);

  public class EntryWrittenEventArgs
  : EventArgs
  public EventLogEntry Entry { get; }

  public sealed class EntryWrittenEventHandler
  : MulticastDelegate, ICloneable, ISerializable
  public virtual IAsyncResult BeginInvoke(Object sender, EntryWrittenEventArgs e, AsyncCallback callback, Object object);
  public virtual void EndInvoke(IAsyncResult result);
  public virtual void Invoke(Object sender, EntryWrittenEventArgs e);

  public class EventInstance
 
  public Int32 CategoryId { get; set; }
  public EventLogEntryType EntryType { get; set; }
  public Int64 InstanceId { get; set; }

  public class EventLog
  : Component, IComponent, IDisposable, ISupportInitialize
  public Boolean EnableRaisingEvents { get; set; }
  public EventLogEntryCollection Entries { get; }
  public String Log { get; set; }
  public String LogDisplayName { get; }
  public String MachineName { get; set; }
  public Int64 MaximumKilobytes { get; set; }
  public Int32 MinimumRetentionDays { get; }
  public OverflowAction OverflowAction { get; }
  public String Source { get; set; }
  public ISynchronizeInvoke SynchronizingObject { get; set; }
  public event EntryWrittenEventHandler EntryWritten;
  public virtual void BeginInit();
  public void Clear();
  public void Close();
  static public void CreateEventSource(String source, String logName);
  static public void CreateEventSource(String source, String logName, String machineName);
  static public void CreateEventSource(EventSourceCreationData sourceData);
  static public void Delete(String logName);
  static public void Delete(String logName, String machineName);
  static public void DeleteEventSource(String source);
  static public void DeleteEventSource(String source, String machineName);
  protected virtual void Dispose(Boolean disposing);
  public virtual void EndInit();
  static public Boolean Exists(String logName);
  static public Boolean Exists(String logName, String machineName);
  static public EventLog GetEventLogs();
  static public EventLog GetEventLogs(String machineName);
  static public String LogNameFromSourceName(String source, String machineName);
  public void ModifyOverflowPolicy(OverflowAction action, Int32 retentionDays);
  public void RegisterDisplayName(String resourceFile, Int64 resourceId);
  static public Boolean SourceExists(String source);
  static public Boolean SourceExists(String source, String machineName);
  public void WriteEntry(String message);
  static public void WriteEntry(String source, String message);
  public void WriteEntry(String message, EventLogEntryType type);
  static public void WriteEntry(String source, String message, EventLogEntryType type);
  public void WriteEntry(String message, EventLogEntryType type, Int32 eventID);
  static public void WriteEntry(String source, String message, EventLogEntryType type, Int32 eventID);
  public void WriteEntry(String message, EventLogEntryType type, Int32 eventID, Int16 category);
  static public void WriteEntry(String source, String message, EventLogEntryType type, Int32 eventID, Int16 category);
  static public void WriteEntry(String source, String message, EventLogEntryType type, Int32 eventID, Int16 category, Byte rawData);
  public void WriteEntry(String message, EventLogEntryType type, Int32 eventID, Int16 category, Byte rawData);
  public void WriteEvent(EventInstance instance, Object values);
  public void WriteEvent(EventInstance instance, Byte data, Object[] values);
  static public void WriteEvent(String source, EventInstance instance, Object values);
  static public void WriteEvent(String source, EventInstance instance, Byte data, Object[] values);

  public sealed class EventLogEntry
  : Component, IComponent, IDisposable, ISerializable
  public String Category { get; }
  public Int16 CategoryNumber { get; }
  public Byte Data { get; }
  public EventLogEntryType EntryType { get; }
  public Int32 EventID { get; }
  public Int32 Index { get; }
  public Int64 InstanceId { get; }
  public String MachineName { get; }
  public String Message { get; }
  public String ReplacementStrings { get; }
  public String Source { get; }
  public DateTime TimeGenerated { get; }
  public DateTime TimeWritten { get; }
  public String UserName { get; }
  public Boolean Equals(EventLogEntry otherEntry);

  public class EventLogEntryCollection
  : ICollection, IEnumerable
  public virtual Int32 Count { get; }
  public virtual EventLogEntry Item { get; }
  public void CopyTo(EventLogEntry entries, Int32 index);
  public virtual IEnumerator GetEnumerator();

  public sealed enum EventLogEntryType
  : IComparable, IFormattable, IConvertible
  { Error, Warning, Information, SuccessAudit, FailureAudit }

  public sealed class EventLogPermission
  : ResourcePermissionBase, IPermission, ISecurityEncodable, IStackWalk, IUnrestrictedPermission
  public EventLogPermissionEntryCollection PermissionEntries { get; }

  public sealed enum EventLogPermissionAccess
  : IComparable, IFormattable, IConvertible
  { None, Write, Administer, Browse, Instrument, Audit }

  public class EventLogPermissionAttribute
  : CodeAccessSecurityAttribute, _Attribute
  public String MachineName { get; set; }
  public EventLogPermissionAccess PermissionAccess { get; set; }
  public virtual IPermission CreatePermission();

  public class EventLogPermissionEntry
 
  public String MachineName { get; }
  public EventLogPermissionAccess PermissionAccess { get; }

  public class EventLogPermissionEntryCollection
  : CollectionBase, IList, ICollection, IEnumerable
  public EventLogPermissionEntry Item { get; set; }
  public Int32 Add(EventLogPermissionEntry value);
  public void AddRange(EventLogPermissionEntry value);
  public void AddRange(EventLogPermissionEntryCollection value);
  public Boolean Contains(EventLogPermissionEntry value);
  public void CopyTo(EventLogPermissionEntry array, Int32 index);
  public Int32 IndexOf(EventLogPermissionEntry value);
  public void Insert(Int32 index, EventLogPermissionEntry value);
  protected virtual void OnClear();
  protected virtual void OnInsert(Int32 index, Object value);
  protected virtual void OnRemove(Int32 index, Object value);
  protected virtual void OnSet(Int32 index, Object oldValue, Object newValue);
  public void Remove(EventLogPermissionEntry value);

  public sealed class EventLogTraceListener
  : TraceListener, IDisposable
  public EventLog EventLog { get; set; }
  public virtual String Name { get; set; }
  public virtual void Close();
  protected virtual void Dispose(Boolean disposing);
  public virtual void TraceData(TraceEventCache eventCache, String source, TraceEventType severity, Int32 id, Object data);
  public virtual void TraceData(TraceEventCache eventCache, String source, TraceEventType severity, Int32 id, Object data);
  public virtual void TraceEvent(TraceEventCache eventCache, String source, TraceEventType severity, Int32 id, String format, Object args);
  public virtual void TraceEvent(TraceEventCache eventCache, String source, TraceEventType severity, Int32 id, String message);
  public virtual void Write(String message);
  public virtual void WriteLine(String message);

  public class EventSchemaTraceListener
  : TextWriterTraceListener, IDisposable
  public Int32 BufferSize { get; }
  public virtual Boolean IsThreadSafe { get; }
  public Int64 MaximumFileSize { get; }
  public Int32 MaximumNumberOfFiles { get; }
  public TraceLogRetentionOption TraceLogRetentionOption { get; }
  public TextWriter Writer { get; set; }
  public virtual void Close();
  public virtual void Fail(String message, String detailMessage);
  public virtual void Flush();
  protected virtual String GetSupportedAttributes();
  public virtual void TraceData(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, Object data);
  public virtual void TraceData(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, Object data);
  public virtual void TraceEvent(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, String format, Object args);
  public virtual void TraceEvent(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, String message);
  public virtual void TraceTransfer(TraceEventCache eventCache, String source, Int32 id, String message, Guid relatedActivityId);
  public virtual void Write(String message);
  public virtual void WriteLine(String message);

  public class EventSourceCreationData
 
  public Int32 CategoryCount { get; set; }
  public String CategoryResourceFile { get; set; }
  public String LogName { get; set; }
  public String MachineName { get; set; }
  public String MessageResourceFile { get; set; }
  public String ParameterResourceFile { get; set; }
  public String Source { get; set; }

  public class EventTypeFilter
  : TraceFilter
  public SourceLevels EventType { get; set; }
  public virtual Boolean ShouldTrace(TraceEventCache cache, String source, TraceEventType eventType, Int32 id, String formatOrMessage, Object args, Object data1, Object[] data);

  public sealed class FileVersionInfo
 
  public String Comments { get; }
  public String CompanyName { get; }
  public Int32 FileBuildPart { get; }
  public String FileDescription { get; }
  public Int32 FileMajorPart { get; }
  public Int32 FileMinorPart { get; }
  public String FileName { get; }
  public Int32 FilePrivatePart { get; }
  public String FileVersion { get; }
  public String InternalName { get; }
  public Boolean IsDebug { get; }
  public Boolean IsPatched { get; }
  public Boolean IsPreRelease { get; }
  public Boolean IsPrivateBuild { get; }
  public Boolean IsSpecialBuild { get; }
  public String Language { get; }
  public String LegalCopyright { get; }
  public String LegalTrademarks { get; }
  public String OriginalFilename { get; }
  public String PrivateBuild { get; }
  public Int32 ProductBuildPart { get; }
  public Int32 ProductMajorPart { get; }
  public Int32 ProductMinorPart { get; }
  public String ProductName { get; }
  public Int32 ProductPrivatePart { get; }
  public String ProductVersion { get; }
  public String SpecialBuild { get; }
  static public FileVersionInfo GetVersionInfo(String fileName);
  public virtual String ToString();

  public abstract interface ICollectData
 
  public abstract virtual void CloseData();
  public abstract virtual void CollectData(Int32 id, IntPtr valueName, IntPtr data, Int32 totalBytes, out IntPtr& res);

  public class InstanceData
 
  public String InstanceName { get; }
  public Int64 RawValue { get; }
  public CounterSample Sample { get; }

  public class InstanceDataCollection
  : DictionaryBase, IDictionary, ICollection, IEnumerable
  public String CounterName { get; }
  public InstanceData Item { get; }
  public ICollection Keys { get; }
  public ICollection Values { get; }
  public Boolean Contains(String instanceName);
  public void CopyTo(InstanceData instances, Int32 index);

  public class InstanceDataCollectionCollection
  : DictionaryBase, IDictionary, ICollection, IEnumerable
  public InstanceDataCollection Item { get; }
  public ICollection Keys { get; }
  public ICollection Values { get; }
  public Boolean Contains(String counterName);
  public void CopyTo(InstanceDataCollection counters, Int32 index);

  public class MonitoringDescriptionAttribute
  : DescriptionAttribute, _Attribute
  public virtual String Description { get; }

  public sealed enum OverflowAction
  : IComparable, IFormattable, IConvertible
  { DoNotOverwrite, OverwriteAsNeeded, OverwriteOlder }

  public sealed class PerformanceCounter
  : Component, IComponent, IDisposable, ISupportInitialize
  public String CategoryName { get; set; }
  public String CounterHelp { get; }
  public String CounterName { get; set; }
  public PerformanceCounterType CounterType { get; }
  public PerformanceCounterInstanceLifetime InstanceLifetime { get; set; }
  public String InstanceName { get; set; }
  public String MachineName { get; set; }
  public Int64 RawValue { get; set; }
  public Boolean ReadOnly { get; set; }
  public virtual void BeginInit();
  public void Close();
  static public void CloseSharedResources();
  public Int64 Decrement();
  protected virtual void Dispose(Boolean disposing);
  public virtual void EndInit();
  public Int64 Increment();
  public Int64 IncrementBy(Int64 value);
  public CounterSample NextSample();
  public Single NextValue();
  public void RemoveInstance();

  public sealed class PerformanceCounterCategory
 
  public String CategoryHelp { get; }
  public String CategoryName { get; set; }
  public PerformanceCounterCategoryType CategoryType { get; }
  public String MachineName { get; set; }
  public Boolean CounterExists(String counterName);
  static public Boolean CounterExists(String counterName, String categoryName);
  static public Boolean CounterExists(String counterName, String categoryName, String machineName);
  static public PerformanceCounterCategory Create(String categoryName, String categoryHelp, String counterName, String counterHelp);
  static public PerformanceCounterCategory Create(String categoryName, String categoryHelp, PerformanceCounterCategoryType categoryType, String counterName, String counterHelp);
  static public PerformanceCounterCategory Create(String categoryName, String categoryHelp, CounterCreationDataCollection counterData);
  static public PerformanceCounterCategory Create(String categoryName, String categoryHelp, PerformanceCounterCategoryType categoryType, CounterCreationDataCollection counterData);
  static public void Delete(String categoryName);
  static public Boolean Exists(String categoryName);
  static public Boolean Exists(String categoryName, String machineName);
  static public PerformanceCounterCategory GetCategories();
  static public PerformanceCounterCategory GetCategories(String machineName);
  public PerformanceCounter GetCounters();
  public PerformanceCounter GetCounters(String instanceName);
  public String GetInstanceNames();
  public Boolean InstanceExists(String instanceName);
  static public Boolean InstanceExists(String instanceName, String categoryName);
  static public Boolean InstanceExists(String instanceName, String categoryName, String machineName);
  public InstanceDataCollectionCollection ReadCategory();

  public sealed enum PerformanceCounterCategoryType
  : IComparable, IFormattable, IConvertible
  { Unknown, SingleInstance, MultiInstance }

  public sealed enum PerformanceCounterInstanceLifetime
  : IComparable, IFormattable, IConvertible
  { Global, Process }

  public sealed class PerformanceCounterManager
  : ICollectData

  public sealed class PerformanceCounterPermission
  : ResourcePermissionBase, IPermission, ISecurityEncodable, IStackWalk, IUnrestrictedPermission
  public PerformanceCounterPermissionEntryCollection PermissionEntries { get; }

  public sealed enum PerformanceCounterPermissionAccess
  : IComparable, IFormattable, IConvertible
  { Browse, Instrument, None, Read, Write, Administer }

  public class PerformanceCounterPermissionAttribute
  : CodeAccessSecurityAttribute, _Attribute
  public String CategoryName { get; set; }
  public String MachineName { get; set; }
  public PerformanceCounterPermissionAccess PermissionAccess { get; set; }
  public virtual IPermission CreatePermission();

  public class PerformanceCounterPermissionEntry
 
  public String CategoryName { get; }
  public String MachineName { get; }
  public PerformanceCounterPermissionAccess PermissionAccess { get; }

  public class PerformanceCounterPermissionEntryCollection
  : CollectionBase, IList, ICollection, IEnumerable
  public PerformanceCounterPermissionEntry Item { get; set; }
  public Int32 Add(PerformanceCounterPermissionEntry value);
  public void AddRange(PerformanceCounterPermissionEntry value);
  public void AddRange(PerformanceCounterPermissionEntryCollection value);
  public Boolean Contains(PerformanceCounterPermissionEntry value);
  public void CopyTo(PerformanceCounterPermissionEntry array, Int32 index);
  public Int32 IndexOf(PerformanceCounterPermissionEntry value);
  public void Insert(Int32 index, PerformanceCounterPermissionEntry value);
  protected virtual void OnClear();
  protected virtual void OnInsert(Int32 index, Object value);
  protected virtual void OnRemove(Int32 index, Object value);
  protected virtual void OnSet(Int32 index, Object oldValue, Object newValue);
  public void Remove(PerformanceCounterPermissionEntry value);

  public sealed enum PerformanceCounterType
  : IComparable, IFormattable, IConvertible
  { NumberOfItems32, NumberOfItems64, NumberOfItemsHEX32, NumberOfItemsHEX64, RateOfCountsPerSecond32, RateOfCountsPerSecond64, CountPerTimeInterval32, CountPerTimeInterval64, RawFraction, RawBase, AverageTimer32, AverageBase, AverageCount64, SampleFraction, SampleCounter, SampleBase, CounterTimer, CounterTimerInverse, Timer100Ns, Timer100NsInverse, ElapsedTime, CounterMultiTimer, CounterMultiTimerInverse, CounterMultiTimer100Ns, CounterMultiTimer100NsInverse, CounterMultiBase, CounterDelta32, CounterDelta64 }

  public class Process
  : Component, IComponent, IDisposable
  public Int32 BasePriority { get; }
  public Boolean EnableRaisingEvents { get; set; }
  public Int32 ExitCode { get; }
  public DateTime ExitTime { get; }
  public IntPtr Handle { get; }
  public Int32 HandleCount { get; }
  public Boolean HasExited { get; }
  public Int32 Id { get; }
  public String MachineName { get; }
  public ProcessModule MainModule { get; }
  public IntPtr MainWindowHandle { get; }
  public String MainWindowTitle { get; }
  public IntPtr MaxWorkingSet { get; set; }
  public IntPtr MinWorkingSet { get; set; }
  public ProcessModuleCollection Modules { get; }
  public Int32 NonpagedSystemMemorySize { get; }
  public Int64 NonpagedSystemMemorySize64 { get; }
  public Int32 PagedMemorySize { get; }
  public Int64 PagedMemorySize64 { get; }
  public Int32 PagedSystemMemorySize { get; }
  public Int64 PagedSystemMemorySize64 { get; }
  public Int32 PeakPagedMemorySize { get; }
  public Int64 PeakPagedMemorySize64 { get; }
  public Int32 PeakVirtualMemorySize { get; }
  public Int64 PeakVirtualMemorySize64 { get; }
  public Int32 PeakWorkingSet { get; }
  public Int64 PeakWorkingSet64 { get; }
  public Boolean PriorityBoostEnabled { get; set; }
  public ProcessPriorityClass PriorityClass { get; set; }
  public Int32 PrivateMemorySize { get; }
  public Int64 PrivateMemorySize64 { get; }
  public TimeSpan PrivilegedProcessorTime { get; }
  public String ProcessName { get; }
  public IntPtr ProcessorAffinity { get; set; }
  public Boolean Responding { get; }
  public Int32 SessionId { get; }
  public StreamReader StandardError { get; }
  public StreamWriter StandardInput { get; }
  public StreamReader StandardOutput { get; }
  public ProcessStartInfo StartInfo { get; set; }
  public DateTime StartTime { get; }
  public ISynchronizeInvoke SynchronizingObject { get; set; }
  public ProcessThreadCollection Threads { get; }
  public TimeSpan TotalProcessorTime { get; }
  public TimeSpan UserProcessorTime { get; }
  public Int32 VirtualMemorySize { get; }
  public Int64 VirtualMemorySize64 { get; }
  public Int32 WorkingSet { get; }
  public Int64 WorkingSet64 { get; }
  public event DataReceivedEventHandler ErrorDataReceived;
  public event EventHandler Exited;
  public event DataReceivedEventHandler OutputDataReceived;
  public void BeginErrorReadLine();
  public void BeginOutputReadLine();
  public void CancelErrorRead();
  public void CancelOutputRead();
  public void Close();
  public Boolean CloseMainWindow();
  protected virtual void Dispose(Boolean disposing);
  static public void EnterDebugMode();
  static public Process GetCurrentProcess();
  static public Process GetProcessById(Int32 processId, String machineName);
  static public Process GetProcessById(Int32 processId);
  static public Process GetProcesses();
  static public Process GetProcesses(String machineName);
  static public Process GetProcessesByName(String processName);
  static public Process GetProcessesByName(String processName, String machineName);
  public void Kill();
  static public void LeaveDebugMode();
  protected void OnExited();
  public void Refresh();
  public Boolean Start();
  static public Process Start(String fileName, String userName, SecureString password, String domain);
  static public Process Start(String fileName, String arguments, String userName, SecureString password, String domain);
  static public Process Start(String fileName);
  static public Process Start(String fileName, String arguments);
  static public Process Start(ProcessStartInfo startInfo);
  public virtual String ToString();
  public Boolean WaitForExit(Int32 milliseconds);
  public void WaitForExit();
  public Boolean WaitForInputIdle(Int32 milliseconds);
  public Boolean WaitForInputIdle();

  public class ProcessModule
  : Component, IComponent, IDisposable
  public IntPtr BaseAddress { get; }
  public IntPtr EntryPointAddress { get; }
  public String FileName { get; }
  public FileVersionInfo FileVersionInfo { get; }
  public Int32 ModuleMemorySize { get; }
  public String ModuleName { get; }
  public virtual String ToString();

  public class ProcessModuleCollection
  : ReadOnlyCollectionBase, ICollection, IEnumerable
  public ProcessModule Item { get; }
  public Boolean Contains(ProcessModule module);
  public void CopyTo(ProcessModule array, Int32 index);
  public Int32 IndexOf(ProcessModule module);

  public sealed enum ProcessPriorityClass
  : IComparable, IFormattable, IConvertible
  { Normal, Idle, High, RealTime, BelowNormal, AboveNormal }

  public sealed class ProcessStartInfo
 
  public String Arguments { get; set; }
  public Boolean CreateNoWindow { get; set; }
  public String Domain { get; set; }
  public StringDictionary EnvironmentVariables { get; }
  public Boolean ErrorDialog { get; set; }
  public IntPtr ErrorDialogParentHandle { get; set; }
  public String FileName { get; set; }
  public Boolean LoadUserProfile { get; set; }
  public SecureString Password { get; set; }
  public Boolean RedirectStandardError { get; set; }
  public Boolean RedirectStandardInput { get; set; }
  public Boolean RedirectStandardOutput { get; set; }
  public Encoding StandardErrorEncoding { get; set; }
  public Encoding StandardOutputEncoding { get; set; }
  public String UserName { get; set; }
  public Boolean UseShellExecute { get; set; }
  public String Verb { get; set; }
  public String Verbs { get; }
  public ProcessWindowStyle WindowStyle { get; set; }
  public String WorkingDirectory { get; set; }

  public class ProcessThread
  : Component, IComponent, IDisposable
  public Int32 BasePriority { get; }
  public Int32 CurrentPriority { get; }
  public Int32 Id { get; }
  public Int32 IdealProcessor { set; }
  public Boolean PriorityBoostEnabled { get; set; }
  public ThreadPriorityLevel PriorityLevel { get; set; }
  public TimeSpan PrivilegedProcessorTime { get; }
  public IntPtr ProcessorAffinity { set; }
  public IntPtr StartAddress { get; }
  public DateTime StartTime { get; }
  public ThreadState ThreadState { get; }
  public TimeSpan TotalProcessorTime { get; }
  public TimeSpan UserProcessorTime { get; }
  public ThreadWaitReason WaitReason { get; }
  public void ResetIdealProcessor();

  public class ProcessThreadCollection
  : ReadOnlyCollectionBase, ICollection, IEnumerable
  public ProcessThread Item { get; }
  public Int32 Add(ProcessThread thread);
  public Boolean Contains(ProcessThread thread);
  public void CopyTo(ProcessThread array, Int32 index);
  public Int32 IndexOf(ProcessThread thread);
  public void Insert(Int32 index, ProcessThread thread);
  public void Remove(ProcessThread thread);

  public sealed enum ProcessWindowStyle
  : IComparable, IFormattable, IConvertible
  { Normal, Hidden, Minimized, Maximized }

  public class SourceFilter
  : TraceFilter
  public String Source { get; set; }
  public virtual Boolean ShouldTrace(TraceEventCache cache, String source, TraceEventType eventType, Int32 id, String formatOrMessage, Object args, Object data1, Object[] data);

  public sealed enum SourceLevels
  : IComparable, IFormattable, IConvertible
  { Off, Critical, Error, Warning, Information, Verbose, ActivityTracing, All }

  public class SourceSwitch
  : Switch
  public SourceLevels Level { get; set; }
  protected virtual void OnValueChanged();
  public Boolean ShouldTrace(TraceEventType eventType);

public class StackFrame public class StackFrame
public virtual Int32 GetFileColumnNumber(); public virtual Int32 GetFileColumnNumber();
public virtual Int32 GetFileLineNumber(); public virtual Int32 GetFileLineNumber();
  public virtual String GetFileName();
public virtual Int32 GetILOffset(); public virtual Int32 GetILOffset();
public virtual MethodBase GetMethod(); public virtual MethodBase GetMethod();
public virtual Int32 GetNativeOffset(); public virtual Int32 GetNativeOffset();
public virtual String ToString(); public virtual String ToString();

public class StackTrace public class StackTrace
public virtual Int32 FrameCount { get; } public virtual Int32 FrameCount { get; }
public virtual StackFrame GetFrame(Int32 index); public virtual StackFrame GetFrame(Int32 index);
public virtual StackFrame GetFrames(); public virtual StackFrame GetFrames();
public virtual String ToString(); public virtual String ToString();

  public class Stopwatch
 
  public TimeSpan Elapsed { get; }
  public Int64 ElapsedMilliseconds { get; }
  public Int64 ElapsedTicks { get; }
  public Boolean IsRunning { get; }
  static public Int64 GetTimestamp();
  public void Reset();
  public void Restart();
  public void Start();
  static public Stopwatch StartNew();
  public void Stop();

  public abstract class Switch
 
  public StringDictionary Attributes { get; }
  public String Description { get; }
  public String DisplayName { get; }
  protected Int32 SwitchSetting { get; set; }
  protected String Value { get; set; }
  internal protected virtual String GetSupportedAttributes();
  protected virtual void OnSwitchSettingChanged();
  protected virtual void OnValueChanged();

  public sealed class SwitchAttribute
  : Attribute, _Attribute
  public String SwitchDescription { get; set; }
  public String SwitchName { get; set; }
  public Type SwitchType { get; set; }
  static public SwitchAttribute GetAll(Assembly assembly);

  public sealed class SwitchLevelAttribute
  : Attribute, _Attribute
  public Type SwitchLevelType { get; set; }

  public class TextWriterTraceListener
  : TraceListener, IDisposable
  public TextWriter Writer { get; set; }
  public virtual void Close();
  protected virtual void Dispose(Boolean disposing);
  public virtual void Flush();
  public virtual void Write(String message);
  public virtual void WriteLine(String message);

  public sealed enum ThreadPriorityLevel
  : IComparable, IFormattable, IConvertible
  { Idle, Lowest, BelowNormal, Normal, AboveNormal, Highest, TimeCritical }

  public sealed enum ThreadWaitReason
  : IComparable, IFormattable, IConvertible
  { Executive, FreePage, PageIn, SystemAllocation, ExecutionDelay, Suspended, UserRequest, EventPairHigh, EventPairLow, LpcReceive, LpcReply, VirtualMemory, PageOut, Unknown }

  public sealed class Trace
 
  static public Boolean AutoFlush { get; set; }
  static public CorrelationManager CorrelationManager { get; }
  static public Int32 IndentLevel { get; set; }
  static public Int32 IndentSize { get; set; }
  static public TraceListenerCollection Listeners { get; }
  static public Boolean UseGlobalLock { get; set; }
  static public void Assert(Boolean condition);
  static public void Assert(Boolean condition, String message);
  static public void Assert(Boolean condition, String message, String detailMessage);
  static public void Close();
  static public void Fail(String message);
  static public void Fail(String message, String detailMessage);
  static public void Flush();
  static public void Indent();
  static public void Refresh();
  static public void TraceError(String message);
  static public void TraceError(String format, Object args);
  static public void TraceInformation(String message);
  static public void TraceInformation(String format, Object args);
  static public void TraceWarning(String message);
  static public void TraceWarning(String format, Object args);
  static public void Unindent();
  static public void Write(String message);
  static public void Write(Object value);
  static public void Write(String message, String category);
  static public void Write(Object value, String category);
  static public void WriteIf(Boolean condition, String message);
  static public void WriteIf(Boolean condition, Object value);
  static public void WriteIf(Boolean condition, String message, String category);
  static public void WriteIf(Boolean condition, Object value, String category);
  static public void WriteLine(String message);
  static public void WriteLine(Object value);
  static public void WriteLine(String message, String category);
  static public void WriteLine(Object value, String category);
  static public void WriteLineIf(Boolean condition, String message);
  static public void WriteLineIf(Boolean condition, Object value);
  static public void WriteLineIf(Boolean condition, String message, String category);
  static public void WriteLineIf(Boolean condition, Object value, String category);

  public class TraceEventCache
 
  public String Callstack { get; }
  public DateTime DateTime { get; }
  public Stack LogicalOperationStack { get; }
  public Int32 ProcessId { get; }
  public String ThreadId { get; }
  public Int64 Timestamp { get; }

  public sealed enum TraceEventType
  : IComparable, IFormattable, IConvertible
  { Critical, Error, Warning, Information, Verbose, Start, Stop, Suspend, Resume, Transfer }

  public abstract class TraceFilter
 
  public abstract virtual Boolean ShouldTrace(TraceEventCache cache, String source, TraceEventType eventType, Int32 id, String formatOrMessage, Object args, Object data1, Object[] data);

  public sealed enum TraceLevel
  : IComparable, IFormattable, IConvertible
  { Off, Error, Warning, Info, Verbose }

  public abstract class TraceListener
  : MarshalByRefObject, IDisposable
  public StringDictionary Attributes { get; }
  public TraceFilter Filter { get; set; }
  public Int32 IndentLevel { get; set; }
  public Int32 IndentSize { get; set; }
  public virtual Boolean IsThreadSafe { get; }
  public virtual String Name { get; set; }
  protected Boolean NeedIndent { get; set; }
  public TraceOptions TraceOutputOptions { get; set; }
  public virtual void Close();
  public virtual void Dispose();
  protected virtual void Dispose(Boolean disposing);
  public virtual void Fail(String message);
  public virtual void Fail(String message, String detailMessage);
  public virtual void Flush();
  internal protected virtual String GetSupportedAttributes();
  public virtual void TraceData(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, Object data);
  public virtual void TraceData(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, Object data);
  public virtual void TraceEvent(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id);
  public virtual void TraceEvent(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, String message);
  public virtual void TraceEvent(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, String format, Object args);
  public virtual void TraceTransfer(TraceEventCache eventCache, String source, Int32 id, String message, Guid relatedActivityId);
  public abstract virtual void Write(String message);
  public virtual void Write(Object o);
  public virtual void Write(String message, String category);
  public virtual void Write(Object o, String category);
  protected virtual void WriteIndent();
  public abstract virtual void WriteLine(String message);
  public virtual void WriteLine(Object o);
  public virtual void WriteLine(String message, String category);
  public virtual void WriteLine(Object o, String category);

  public class TraceListenerCollection
  : IList, ICollection, IEnumerable
  public virtual Int32 Count { get; }
  public TraceListener Item { get; set; }
  public TraceListener Item { get; }
  public Int32 Add(TraceListener listener);
  public void AddRange(TraceListener value);
  public void AddRange(TraceListenerCollection value);
  public virtual void Clear();
  public Boolean Contains(TraceListener listener);
  public void CopyTo(TraceListener listeners, Int32 index);
  public virtual IEnumerator GetEnumerator();
  public Int32 IndexOf(TraceListener listener);
  public void Insert(Int32 index, TraceListener listener);
  public void Remove(TraceListener listener);
  public void Remove(String name);
  public virtual void RemoveAt(Int32 index);

  public sealed enum TraceLogRetentionOption
  : IComparable, IFormattable, IConvertible
  { SingleFileUnboundedSize, SingleFileBoundedSize, UnlimitedSequentialFiles, LimitedSequentialFiles, LimitedCircularFiles }

  public sealed enum TraceOptions
  : IComparable, IFormattable, IConvertible
  { None, LogicalOperationStack, DateTime, Timestamp, ProcessId, ThreadId, Callstack }

  public class TraceSource
 
  public StringDictionary Attributes { get; }
  public TraceListenerCollection Listeners { get; }
  public String Name { get; }
  public SourceSwitch Switch { get; set; }
  public void Close();
  public void Flush();
  internal protected virtual String GetSupportedAttributes();
  public void TraceData(TraceEventType eventType, Int32 id, Object data);
  public void TraceData(TraceEventType eventType, Int32 id, Object data);
  public void TraceEvent(TraceEventType eventType, Int32 id);
  public void TraceEvent(TraceEventType eventType, Int32 id, String message);
  public void TraceEvent(TraceEventType eventType, Int32 id, String format, Object args);
  public void TraceInformation(String message);
  public void TraceInformation(String format, Object args);
  public void TraceTransfer(Int32 id, String message, Guid relatedActivityId);

  public class TraceSwitch
  : Switch
  public TraceLevel Level { get; set; }
  public Boolean TraceError { get; }
  public Boolean TraceInfo { get; }
  public Boolean TraceVerbose { get; }
  public Boolean TraceWarning { get; }
  protected virtual void OnSwitchSettingChanged();
  protected virtual void OnValueChanged();

  public class UnescapedXmlDiagnosticData
 
  public String UnescapedXml { get; set; }
  public virtual String ToString();

  public class XmlWriterTraceListener
  : TextWriterTraceListener, IDisposable
  public virtual void Close();
  public virtual void Fail(String message, String detailMessage);
  public virtual void TraceData(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, Object data);
  public virtual void TraceData(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, Object data);
  public virtual void TraceEvent(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, String format, Object args);
  public virtual void TraceEvent(TraceEventCache eventCache, String source, TraceEventType eventType, Int32 id, String message);
  public virtual void TraceTransfer(TraceEventCache eventCache, String source, Int32 id, String message, Guid relatedActivityId);
  public virtual void Write(String message);
  public virtual void WriteLine(String message);