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);