Silverlight 5

WinRT

	public class AbandonedMutexException
	: SystemException, ISerializable, _Exception
	public Mutex Mutex { get; }
	public Int32 MutexIndex { get; }

	public sealed enum ApartmentState
	: IComparable, IFormattable, IConvertible
	{ STA, MTA, Unknown }

	public sealed struct AsyncFlowControl
	: ValueType, IDisposable
	public virtual void Dispose();
	public virtual Boolean Equals(Object obj);
	public Boolean Equals(AsyncFlowControl obj);
	public virtual Int32 GetHashCode();
	static public Boolean op_Equality(AsyncFlowControl a, AsyncFlowControl b);
	static public Boolean op_Inequality(AsyncFlowControl a, AsyncFlowControl b);
	public void Undo();

public sealed class AutoResetEvent	public sealed class AutoResetEvent
: EventWaitHandle, IDisposable	: EventWaitHandle, IDisposable

	public class Barrier
	: IDisposable
	public Int64 CurrentPhaseNumber { get; set; }
	public Int32 ParticipantCount { get; }
	public Int32 ParticipantsRemaining { get; }
	public Int64 AddParticipant();
	public Int64 AddParticipants(Int32 participantCount);
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
	public void RemoveParticipant();
	public void RemoveParticipants(Int32 participantCount);
	public void SignalAndWait();
	public void SignalAndWait(CancellationToken cancellationToken);
	public Boolean SignalAndWait(TimeSpan timeout);
	public Boolean SignalAndWait(TimeSpan timeout, CancellationToken cancellationToken);
	public Boolean SignalAndWait(Int32 millisecondsTimeout);
	public Boolean SignalAndWait(Int32 millisecondsTimeout, CancellationToken cancellationToken);

	public class BarrierPostPhaseException
	: Exception, ISerializable, _Exception

public sealed struct CancellationToken	public sealed struct CancellationToken
: ValueType	: ValueType
public Boolean CanBeCanceled { get; }	public Boolean CanBeCanceled { get; }
public Boolean IsCancellationRequested { get; }	public Boolean IsCancellationRequested { get; }
static public CancellationToken None { get; }	static public CancellationToken None { get; }
public WaitHandle WaitHandle { get; }	public WaitHandle WaitHandle { get; }
public Boolean Equals(CancellationToken other);	public Boolean Equals(CancellationToken other);
public virtual Boolean Equals(Object other);	public virtual Boolean Equals(Object other);
public virtual Int32 GetHashCode();	public virtual Int32 GetHashCode();
static public Boolean op_Equality(CancellationToken left, CancellationToken right);	static public Boolean op_Equality(CancellationToken left, CancellationToken right);
static public Boolean op_Inequality(CancellationToken left, CancellationToken right);	static public Boolean op_Inequality(CancellationToken left, CancellationToken right);
	public CancellationTokenRegistration Register(Action`1<Object> callback, Object state);
public CancellationTokenRegistration Register(Action callback);	public CancellationTokenRegistration Register(Action callback);
public CancellationTokenRegistration Register(Action callback, Boolean useSynchronizationContext);	public CancellationTokenRegistration Register(Action callback, Boolean useSynchronizationContext);
public CancellationTokenRegistration Register(Action`1<Object> callback, Object state);	public CancellationTokenRegistration Register(Action`1<Object> callback, Object state, Boolean useSynchronizationContext);
public CancellationTokenRegistration Register(Action`1<Object> callback, Object state, Boolean useSynchronizationContext);
public void ThrowIfCancellationRequested();	public void ThrowIfCancellationRequested();

public sealed struct CancellationTokenRegistration	public sealed struct CancellationTokenRegistration
: ValueType, IEquatable`1<CancellationTokenRegistration>, IDisposable	: ValueType, IEquatable`1<CancellationTokenRegistration>, IDisposable
public virtual void Dispose();	public virtual void Dispose();
public virtual Boolean Equals(Object obj);	public virtual Boolean Equals(Object obj);
public virtual Boolean Equals(CancellationTokenRegistration other);	public virtual Boolean Equals(CancellationTokenRegistration other);
public virtual Int32 GetHashCode();	public virtual Int32 GetHashCode();
static public Boolean op_Equality(CancellationTokenRegistration left, CancellationTokenRegistration right);	static public Boolean op_Equality(CancellationTokenRegistration left, CancellationTokenRegistration right);
static public Boolean op_Inequality(CancellationTokenRegistration left, CancellationTokenRegistration right);	static public Boolean op_Inequality(CancellationTokenRegistration left, CancellationTokenRegistration right);

public sealed class CancellationTokenSource	public class CancellationTokenSource
: IDisposable	: IDisposable
public Boolean IsCancellationRequested { get; }	public Boolean IsCancellationRequested { get; }
public CancellationToken Token { get; }	public CancellationToken Token { get; }
public void Cancel();	public void Cancel();
public void Cancel(Boolean throwOnFirstException);	public void Cancel(Boolean throwOnFirstException);
	public void CancelAfter(TimeSpan delay);
	public void CancelAfter(Int32 millisecondsDelay);
static public CancellationTokenSource CreateLinkedTokenSource(CancellationToken token1, CancellationToken token2);	static public CancellationTokenSource CreateLinkedTokenSource(CancellationToken token1, CancellationToken token2);
static public CancellationTokenSource CreateLinkedTokenSource(CancellationToken tokens);	static public CancellationTokenSource CreateLinkedTokenSource(CancellationToken tokens);
public virtual void Dispose();	public virtual void Dispose();

	public sealed class CompressedStack
	: ISerializable
	static public CompressedStack Capture();
	public CompressedStack CreateCopy();
	static public CompressedStack GetCompressedStack();
	public virtual void GetObjectData(SerializationInfo info, StreamingContext context);
	static public void Run(CompressedStack compressedStack, ContextCallback callback, Object state);

	public sealed class ContextCallback
	: MulticastDelegate, ICloneable, ISerializable
	public virtual IAsyncResult BeginInvoke(Object state, AsyncCallback callback, Object object);
	public virtual void EndInvoke(IAsyncResult result);
	public virtual void Invoke(Object state);

	public class CountdownEvent
	: IDisposable
	public Int32 CurrentCount { get; }
	public Int32 InitialCount { get; }
	public Boolean IsSet { get; }
	public WaitHandle WaitHandle { get; }
	public void AddCount();
	public void AddCount(Int32 signalCount);
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
	public void Reset();
	public void Reset(Int32 count);
	public Boolean Signal();
	public Boolean Signal(Int32 signalCount);
	public Boolean TryAddCount();
	public Boolean TryAddCount(Int32 signalCount);
	public void Wait();
	public void Wait(CancellationToken cancellationToken);
	public Boolean Wait(TimeSpan timeout);
	public Boolean Wait(TimeSpan timeout, CancellationToken cancellationToken);
	public Boolean Wait(Int32 millisecondsTimeout);
	public Boolean Wait(Int32 millisecondsTimeout, CancellationToken cancellationToken);

	public sealed enum EventResetMode
	: IComparable, IFormattable, IConvertible
	{ AutoReset, ManualReset }

public class EventWaitHandle	public class EventWaitHandle
: WaitHandle, IDisposable	: WaitHandle, IDisposable
	public EventWaitHandleSecurity GetAccessControl();
	static public EventWaitHandle OpenExisting(String name);
	static public EventWaitHandle OpenExisting(String name, EventWaitHandleRights rights);
public Boolean Reset();	public Boolean Reset();
public Boolean Set();	public Boolean Set();
	public void SetAccessControl(EventWaitHandleSecurity eventSecurity);
	static public Boolean TryOpenExisting(String name, out EventWaitHandle& result);

	public sealed class ExecutionContext
	: IDisposable, ISerializable
	static public ExecutionContext Capture();
	public ExecutionContext CreateCopy();
	public virtual void Dispose();
	public virtual void GetObjectData(SerializationInfo info, StreamingContext context);
	static public Boolean IsFlowSuppressed();
	static public void RestoreFlow();
	static public void Run(ExecutionContext executionContext, ContextCallback callback, Object state);
	static public AsyncFlowControl SuppressFlow();

	public class HostExecutionContext
	: IDisposable
	internal protected Object State { get; set; }
	public virtual HostExecutionContext CreateCopy();
	public virtual void Dispose();
	public virtual void Dispose(Boolean disposing);

	public class HostExecutionContextManager
	public virtual HostExecutionContext Capture();
	public virtual void Revert(Object previousState);
	public virtual Object SetHostExecutionContext(HostExecutionContext hostExecutionContext);

public abstract sealed class Interlocked	public abstract sealed class Interlocked
static public Int32 Add(Int32& location1, Int32 value);	static public Int32 Add(Int32& location1, Int32 value);
static public Int64 Add(Int64& location1, Int64 value);	static public Int64 Add(Int64& location1, Int64 value);
static public Int32 CompareExchange(Int32& location1, Int32 value, Int32 comparand);	static public Int32 CompareExchange(Int32& location1, Int32 value, Int32 comparand);
static public Int64 CompareExchange(Int64& location1, Int64 value, Int64 comparand);	static public Int64 CompareExchange(Int64& location1, Int64 value, Int64 comparand);
	static public Single CompareExchange(Single& location1, Single value, Single comparand);
	static public Double CompareExchange(Double& location1, Double value, Double comparand);
static public Object CompareExchange(Object& location1, Object value, Object comparand);	static public Object CompareExchange(Object& location1, Object value, Object comparand);
	static public IntPtr CompareExchange(IntPtr& location1, IntPtr value, IntPtr comparand);
static public T CompareExchange(T& location1, T value, T comparand);	static public T CompareExchange(T& location1, T value, T comparand);
static public Int32 Decrement(Int32& location);	static public Int32 Decrement(Int32& location);
static public Int64 Decrement(Int64& location);	static public Int64 Decrement(Int64& location);
static public Int32 Exchange(Int32& location1, Int32 value);	static public Int32 Exchange(Int32& location1, Int32 value);
static public Int64 Exchange(Int64& location1, Int64 value);	static public Int64 Exchange(Int64& location1, Int64 value);
	static public Single Exchange(Single& location1, Single value);
	static public Double Exchange(Double& location1, Double value);
	static public Object Exchange(Object& location1, Object value);
	static public IntPtr Exchange(IntPtr& location1, IntPtr value);
static public T Exchange(T& location1, T value);	static public T Exchange(T& location1, T value);
static public Int32 Increment(Int32& location);	static public Int32 Increment(Int32& location);
static public Int64 Increment(Int64& location);	static public Int64 Increment(Int64& location);

public sealed class IOCompletionCallback	public sealed class IOCompletionCallback
: MulticastDelegate, ICloneable	: MulticastDelegate, ICloneable, ISerializable
public virtual IAsyncResult BeginInvoke(UInt32 errorCode, UInt32 numBytes, NativeOverlapped pOVERLAP, AsyncCallback callback, Object object);	public virtual IAsyncResult BeginInvoke(UInt32 errorCode, UInt32 numBytes, NativeOverlapped pOVERLAP, AsyncCallback callback, Object object);
public virtual void EndInvoke(IAsyncResult result);	public virtual void EndInvoke(IAsyncResult result);
public virtual void Invoke(UInt32 errorCode, UInt32 numBytes, NativeOverlapped pOVERLAP);	public virtual void Invoke(UInt32 errorCode, UInt32 numBytes, NativeOverlapped pOVERLAP);

	public abstract sealed class LazyInitializer
	static public T EnsureInitialized(T& target);
	static public T EnsureInitialized(T& target, Func`1<T> valueFactory);
	static public T EnsureInitialized(T& target, Boolean& initialized, Object& syncLock);
	static public T EnsureInitialized(T& target, Boolean& initialized, Object& syncLock, Func`1<T> valueFactory);

public sealed enum LazyThreadSafetyMode	public sealed enum LazyThreadSafetyMode
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ None, PublicationOnly, ExecutionAndPublication }	{ None, PublicationOnly, ExecutionAndPublication }

	public sealed struct LockCookie
	: ValueType
	public virtual Boolean Equals(Object obj);
	public Boolean Equals(LockCookie obj);
	public virtual Int32 GetHashCode();
	static public Boolean op_Equality(LockCookie a, LockCookie b);
	static public Boolean op_Inequality(LockCookie a, LockCookie b);

	public class LockRecursionException
	: Exception, ISerializable, _Exception

	public sealed enum LockRecursionPolicy
	: IComparable, IFormattable, IConvertible
	{ NoRecursion, SupportsRecursion }

public sealed class ManualResetEvent	public sealed class ManualResetEvent
: EventWaitHandle, IDisposable	: EventWaitHandle, IDisposable

	public class ManualResetEventSlim
	: IDisposable
	public Boolean IsSet { get; set; }
	public Int32 SpinCount { get; set; }
	public WaitHandle WaitHandle { get; }
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
	public void Reset();
	public void Set();
	public void Wait();
	public void Wait(CancellationToken cancellationToken);
	public Boolean Wait(TimeSpan timeout);
	public Boolean Wait(TimeSpan timeout, CancellationToken cancellationToken);
	public Boolean Wait(Int32 millisecondsTimeout);
	public Boolean Wait(Int32 millisecondsTimeout, CancellationToken cancellationToken);

public abstract sealed class Monitor	public abstract sealed class Monitor
static public void Enter(Object obj);	static public void Enter(Object obj);
static public void Enter(Object obj, Boolean& lockTaken);	static public void Enter(Object obj, Boolean& lockTaken);
static public void Exit(Object obj);	static public void Exit(Object obj);
	static public Boolean IsEntered(Object obj);
static public void Pulse(Object obj);	static public void Pulse(Object obj);
static public void PulseAll(Object obj);	static public void PulseAll(Object obj);
static public Boolean TryEnter(Object obj);	static public Boolean TryEnter(Object obj);
static public void TryEnter(Object obj, Boolean& lockTaken);	static public void TryEnter(Object obj, Boolean& lockTaken);
static public Boolean TryEnter(Object obj, Int32 millisecondsTimeout);	static public Boolean TryEnter(Object obj, Int32 millisecondsTimeout);
static public Boolean TryEnter(Object obj, TimeSpan timeout);	static public Boolean TryEnter(Object obj, TimeSpan timeout);
static public void TryEnter(Object obj, Int32 millisecondsTimeout, Boolean& lockTaken);	static public void TryEnter(Object obj, Int32 millisecondsTimeout, Boolean& lockTaken);
static public void TryEnter(Object obj, TimeSpan timeout, Boolean& lockTaken);	static public void TryEnter(Object obj, TimeSpan timeout, Boolean& lockTaken);
	static public Boolean Wait(Object obj, Int32 millisecondsTimeout, Boolean exitContext);
	static public Boolean Wait(Object obj, TimeSpan timeout, Boolean exitContext);
static public Boolean Wait(Object obj, Int32 millisecondsTimeout);	static public Boolean Wait(Object obj, Int32 millisecondsTimeout);
static public Boolean Wait(Object obj, TimeSpan timeout);	static public Boolean Wait(Object obj, TimeSpan timeout);
static public Boolean Wait(Object obj);	static public Boolean Wait(Object obj);

	public sealed class Mutex
	: WaitHandle, IDisposable
	public MutexSecurity GetAccessControl();
	static public Mutex OpenExisting(String name);
	static public Mutex OpenExisting(String name, MutexRights rights);
	public void ReleaseMutex();
	public void SetAccessControl(MutexSecurity mutexSecurity);
	static public Boolean TryOpenExisting(String name, out Mutex& result);
	static public Boolean TryOpenExisting(String name, MutexRights rights, out Mutex& result);

public sealed struct NativeOverlapped	public sealed struct NativeOverlapped
: ValueType	: ValueType

public class Overlapped	public class Overlapped
public IAsyncResult AsyncResult { get; set; }	public IAsyncResult AsyncResult { get; set; }
	public Int32 EventHandle { get; set; }
	public IntPtr EventHandleIntPtr { get; set; }
public Int32 OffsetHigh { get; set; }	public Int32 OffsetHigh { get; set; }
public Int32 OffsetLow { get; set; }	public Int32 OffsetLow { get; set; }
	static public void Free(NativeOverlapped nativeOverlappedPtr);
	public NativeOverlapped Pack(IOCompletionCallback iocb, Object userData);
	public NativeOverlapped Pack(IOCompletionCallback iocb);
	static public Overlapped Unpack(NativeOverlapped nativeOverlappedPtr);
	public NativeOverlapped UnsafePack(IOCompletionCallback iocb, Object userData);

public sealed class ParameterizedThreadStart	public sealed class ParameterizedThreadStart
: MulticastDelegate, ICloneable	: MulticastDelegate, ICloneable, ISerializable
public virtual IAsyncResult BeginInvoke(Object obj, AsyncCallback callback, Object object);	public virtual IAsyncResult BeginInvoke(Object obj, AsyncCallback callback, Object object);
public virtual void EndInvoke(IAsyncResult result);	public virtual void EndInvoke(IAsyncResult result);
public virtual void Invoke(Object obj);	public virtual void Invoke(Object obj);

	public sealed class ReaderWriterLock
	: CriticalFinalizerObject
	public Boolean IsReaderLockHeld { get; }
	public Boolean IsWriterLockHeld { get; }
	public Int32 WriterSeqNum { get; }
	public void AcquireReaderLock(Int32 millisecondsTimeout);
	public void AcquireReaderLock(TimeSpan timeout);
	public void AcquireWriterLock(Int32 millisecondsTimeout);
	public void AcquireWriterLock(TimeSpan timeout);
	public Boolean AnyWritersSince(Int32 seqNum);
	public void DowngradeFromWriterLock(LockCookie& lockCookie);
	protected virtual void Finalize();
	public LockCookie ReleaseLock();
	public void ReleaseReaderLock();
	public void ReleaseWriterLock();
	public void RestoreLock(LockCookie& lockCookie);
	public LockCookie UpgradeToWriterLock(Int32 millisecondsTimeout);
	public LockCookie UpgradeToWriterLock(TimeSpan timeout);

	public class ReaderWriterLockSlim
	: IDisposable
	public Int32 CurrentReadCount { get; }
	public Boolean IsReadLockHeld { get; }
	public Boolean IsUpgradeableReadLockHeld { get; }
	public Boolean IsWriteLockHeld { get; }
	public LockRecursionPolicy RecursionPolicy { get; }
	public Int32 RecursiveReadCount { get; }
	public Int32 RecursiveUpgradeCount { get; }
	public Int32 RecursiveWriteCount { get; }
	public Int32 WaitingReadCount { get; }
	public Int32 WaitingUpgradeCount { get; }
	public Int32 WaitingWriteCount { get; }
	public virtual void Dispose();
	public void EnterReadLock();
	public void EnterUpgradeableReadLock();
	public void EnterWriteLock();
	public void ExitReadLock();
	public void ExitUpgradeableReadLock();
	public void ExitWriteLock();
	public Boolean TryEnterReadLock(TimeSpan timeout);
	public Boolean TryEnterReadLock(Int32 millisecondsTimeout);
	public Boolean TryEnterUpgradeableReadLock(TimeSpan timeout);
	public Boolean TryEnterUpgradeableReadLock(Int32 millisecondsTimeout);
	public Boolean TryEnterWriteLock(TimeSpan timeout);
	public Boolean TryEnterWriteLock(Int32 millisecondsTimeout);

public sealed class RegisteredWaitHandle	public sealed class RegisteredWaitHandle
	: MarshalByRefObject
public Boolean Unregister(WaitHandle waitObject);	public Boolean Unregister(WaitHandle waitObject);

	public sealed class Semaphore
	: WaitHandle, IDisposable
	public SemaphoreSecurity GetAccessControl();
	static public Semaphore OpenExisting(String name);
	static public Semaphore OpenExisting(String name, SemaphoreRights rights);
	public Int32 Release(Int32 releaseCount);
	public Int32 Release();
	public void SetAccessControl(SemaphoreSecurity semaphoreSecurity);
	static public Boolean TryOpenExisting(String name, out Semaphore& result);
	static public Boolean TryOpenExisting(String name, SemaphoreRights rights, out Semaphore& result);

	public class SemaphoreFullException
	: SystemException, ISerializable, _Exception

	public class SemaphoreSlim
	: IDisposable
	public WaitHandle AvailableWaitHandle { get; }
	public Int32 CurrentCount { get; }
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
	public Int32 Release();
	public Int32 Release(Int32 releaseCount);
	public void Wait();
	public void Wait(CancellationToken cancellationToken);
	public Boolean Wait(TimeSpan timeout);
	public Boolean Wait(TimeSpan timeout, CancellationToken cancellationToken);
	public Boolean Wait(Int32 millisecondsTimeout);
	public Boolean Wait(Int32 millisecondsTimeout, CancellationToken cancellationToken);

public sealed class SendOrPostCallback	public sealed class SendOrPostCallback
: MulticastDelegate, ICloneable	: MulticastDelegate, ICloneable, ISerializable
public virtual IAsyncResult BeginInvoke(Object state, AsyncCallback callback, Object object);	public virtual IAsyncResult BeginInvoke(Object state, AsyncCallback callback, Object object);
public virtual void EndInvoke(IAsyncResult result);	public virtual void EndInvoke(IAsyncResult result);
public virtual void Invoke(Object state);	public virtual void Invoke(Object state);

	public sealed struct SpinLock
	: ValueType
	public Boolean IsHeld { get; }
	public Boolean IsHeldByCurrentThread { get; }
	public Boolean IsThreadOwnerTrackingEnabled { get; }
	public void Enter(Boolean& lockTaken);
	public void Exit();
	public void Exit(Boolean useMemoryBarrier);
	public void TryEnter(Boolean& lockTaken);
	public void TryEnter(TimeSpan timeout, Boolean& lockTaken);
	public void TryEnter(Int32 millisecondsTimeout, Boolean& lockTaken);

	public sealed struct SpinWait
	: ValueType
	public Int32 Count { get; }
	public Boolean NextSpinWillYield { get; }
	public void Reset();
	public void SpinOnce();
	static public void SpinUntil(Func`1<Boolean> condition);
	static public Boolean SpinUntil(Func`1<Boolean> condition, TimeSpan timeout);
	static public Boolean SpinUntil(Func`1<Boolean> condition, Int32 millisecondsTimeout);

public class SynchronizationContext	public class SynchronizationContext
static public SynchronizationContext Current { get; }	static public SynchronizationContext Current { get; }
public virtual SynchronizationContext CreateCopy();	public virtual SynchronizationContext CreateCopy();
	public Boolean IsWaitNotificationRequired();
public virtual void OperationCompleted();	public virtual void OperationCompleted();
public virtual void OperationStarted();	public virtual void OperationStarted();
public virtual void Post(SendOrPostCallback d, Object state);	public virtual void Post(SendOrPostCallback d, Object state);
public virtual void Send(SendOrPostCallback d, Object state);	public virtual void Send(SendOrPostCallback d, Object state);
static public void SetSynchronizationContext(SynchronizationContext syncContext);	static public void SetSynchronizationContext(SynchronizationContext syncContext);
	protected void SetWaitNotificationRequired();
	public virtual Int32 Wait(IntPtr waitHandles, Boolean waitAll, Int32 millisecondsTimeout);

public class SynchronizationLockException	public class SynchronizationLockException
: SystemException, _Exception	: SystemException, ISerializable, _Exception

public sealed class Thread	public sealed class Thread
: CriticalFinalizerObject, _Thread	: CriticalFinalizerObject, _Thread
	public ApartmentState ApartmentState { get; set; }
	static public Context CurrentContext { get; }
public CultureInfo CurrentCulture { get; set; }	public CultureInfo CurrentCulture { get; set; }
	static public IPrincipal CurrentPrincipal { get; set; }
static public Thread CurrentThread { get; }	static public Thread CurrentThread { get; }
public CultureInfo CurrentUICulture { get; set; }	public CultureInfo CurrentUICulture { get; set; }
	public ExecutionContext ExecutionContext { get; }
public Boolean IsAlive { get; }	public Boolean IsAlive { get; }
public Boolean IsBackground { get; set; }	public Boolean IsBackground { get; set; }
	public Boolean IsThreadPoolThread { get; }
public Int32 ManagedThreadId { get; }	public Int32 ManagedThreadId { get; }
public String Name { get; set; }	public String Name { get; set; }
	public ThreadPriority Priority { get; set; }
public ThreadState ThreadState { get; }	public ThreadState ThreadState { get; }
	public void Abort(Object stateInfo);
public void Abort();	public void Abort();
	static public LocalDataStoreSlot AllocateDataSlot();
	static public LocalDataStoreSlot AllocateNamedDataSlot(String name);
	static public void BeginCriticalRegion();
	static public void BeginThreadAffinity();
	public void DisableComObjectEagerCleanup();
	static public void EndCriticalRegion();
	static public void EndThreadAffinity();
	protected virtual void Finalize();
	static public void FreeNamedDataSlot(String name);
	public ApartmentState GetApartmentState();
	public CompressedStack GetCompressedStack();
	static public Object GetData(LocalDataStoreSlot slot);
static public AppDomain GetDomain();	static public AppDomain GetDomain();
	static public Int32 GetDomainID();
public virtual Int32 GetHashCode();	public virtual Int32 GetHashCode();
	static public LocalDataStoreSlot GetNamedDataSlot(String name);
	public void Interrupt();
public void Join();	public void Join();
public Boolean Join(Int32 millisecondsTimeout);	public Boolean Join(Int32 millisecondsTimeout);
	public Boolean Join(TimeSpan timeout);
static public void MemoryBarrier();	static public void MemoryBarrier();
	static public void ResetAbort();
	public void Resume();
	public void SetApartmentState(ApartmentState state);
	public void SetCompressedStack(CompressedStack stack);
	static public void SetData(LocalDataStoreSlot slot, Object data);
static public void Sleep(Int32 millisecondsTimeout);	static public void Sleep(Int32 millisecondsTimeout);
static public void Sleep(TimeSpan timeout);	static public void Sleep(TimeSpan timeout);
static public void SpinWait(Int32 iterations);	static public void SpinWait(Int32 iterations);
public void Start();	public void Start();
public void Start(Object parameter);	public void Start(Object parameter);
	public void Suspend();
	public Boolean TrySetApartmentState(ApartmentState state);
	static public Byte VolatileRead(Byte& address);
	static public Int16 VolatileRead(Int16& address);
	static public Int32 VolatileRead(Int32& address);
	static public Int64 VolatileRead(Int64& address);
	static public SByte VolatileRead(SByte& address);
	static public UInt16 VolatileRead(UInt16& address);
	static public UInt32 VolatileRead(UInt32& address);
	static public IntPtr VolatileRead(IntPtr& address);
	static public UIntPtr VolatileRead(UIntPtr& address);
	static public UInt64 VolatileRead(UInt64& address);
	static public Single VolatileRead(Single& address);
	static public Double VolatileRead(Double& address);
	static public Object VolatileRead(Object& address);
	static public void VolatileWrite(Byte& address, Byte value);
	static public void VolatileWrite(Int16& address, Int16 value);
	static public void VolatileWrite(Int32& address, Int32 value);
	static public void VolatileWrite(Int64& address, Int64 value);
	static public void VolatileWrite(SByte& address, SByte value);
	static public void VolatileWrite(UInt16& address, UInt16 value);
	static public void VolatileWrite(UInt32& address, UInt32 value);
	static public void VolatileWrite(IntPtr& address, IntPtr value);
	static public void VolatileWrite(UIntPtr& address, UIntPtr value);
	static public void VolatileWrite(UInt64& address, UInt64 value);
	static public void VolatileWrite(Single& address, Single value);
	static public void VolatileWrite(Double& address, Double value);
	static public void VolatileWrite(Object& address, Object value);

public sealed class ThreadAbortException	public sealed class ThreadAbortException
: SystemException, _Exception	: SystemException, ISerializable, _Exception

	public class ThreadExceptionEventArgs
	: EventArgs
	public Exception Exception { get; }

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

	public class ThreadInterruptedException
	: SystemException, ISerializable, _Exception

	public class ThreadLocal`1<T>
	: IDisposable
	public Boolean IsValueCreated { get; }
	public T Value { get; set; }
	public IEnumerable`1<T> Values { get; }
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
	protected virtual void Finalize();
	public virtual String ToString();

public abstract sealed class ThreadPool	public abstract sealed class ThreadPool
	static public Boolean BindHandle(IntPtr osHandle);
	static public Boolean BindHandle(SafeHandle osHandle);
	static public void GetAvailableThreads(out Int32& workerThreads, out Int32& completionPortThreads);
static public void GetMaxThreads(out Int32& workerThreads, out Int32& completionPortThreads);	static public void GetMaxThreads(out Int32& workerThreads, out Int32& completionPortThreads);
static public void GetMinThreads(out Int32& workerThreads, out Int32& completionPortThreads);	static public void GetMinThreads(out Int32& workerThreads, out Int32& completionPortThreads);
static public Boolean QueueUserWorkItem(WaitCallback callBack, Object state);	static public Boolean QueueUserWorkItem(WaitCallback callBack, Object state);
static public Boolean QueueUserWorkItem(WaitCallback callBack);	static public Boolean QueueUserWorkItem(WaitCallback callBack);
static public RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, Object state, UInt32 millisecondsTimeOutInterval, Boolean executeOnlyOnce);	static public RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, Object state, UInt32 millisecondsTimeOutInterval, Boolean executeOnlyOnce);
static public RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, Object state, Int32 millisecondsTimeOutInterval, Boolean executeOnlyOnce);	static public RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, Object state, Int32 millisecondsTimeOutInterval, Boolean executeOnlyOnce);
static public RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, Object state, Int64 millisecondsTimeOutInterval, Boolean executeOnlyOnce);	static public RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, Object state, Int64 millisecondsTimeOutInterval, Boolean executeOnlyOnce);
static public RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, Object state, TimeSpan timeout, Boolean executeOnlyOnce);	static public RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, Object state, TimeSpan timeout, Boolean executeOnlyOnce);
static public Boolean SetMaxThreads(Int32 workerThreads, Int32 completionPortThreads);	static public Boolean SetMaxThreads(Int32 workerThreads, Int32 completionPortThreads);
static public Boolean SetMinThreads(Int32 workerThreads, Int32 completionPortThreads);	static public Boolean SetMinThreads(Int32 workerThreads, Int32 completionPortThreads);
	static public Boolean UnsafeQueueNativeOverlapped(NativeOverlapped overlapped);
	static public Boolean UnsafeQueueUserWorkItem(WaitCallback callBack, Object state);
	static public RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, Object state, UInt32 millisecondsTimeOutInterval, Boolean executeOnlyOnce);
	static public RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, Object state, Int32 millisecondsTimeOutInterval, Boolean executeOnlyOnce);
	static public RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, Object state, Int64 millisecondsTimeOutInterval, Boolean executeOnlyOnce);

	public sealed enum ThreadPriority
	: IComparable, IFormattable, IConvertible
	{ Lowest, BelowNormal, Normal, AboveNormal, Highest }

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

public sealed class ThreadStartException	public sealed class ThreadStartException
: SystemException, _Exception	: SystemException, ISerializable, _Exception

public sealed enum ThreadState	public sealed enum ThreadState
: IComparable, IFormattable, IConvertible	: IComparable, IFormattable, IConvertible
{ Running, StopRequested, SuspendRequested, Background, Unstarted, Stopped, WaitSleepJoin, Suspended, AbortRequested, Aborted }	{ Initialized, Ready, Running, Standby, Terminated, Wait, Transition, Unknown }

	public sealed enum ThreadState
	: IComparable, IFormattable, IConvertible
	{ Running, StopRequested, SuspendRequested, Background, Unstarted, Stopped, WaitSleepJoin, Suspended, AbortRequested, Aborted }

public class ThreadStateException	public class ThreadStateException
: SystemException, _Exception	: SystemException, ISerializable, _Exception

public abstract sealed class Timeout	public abstract sealed class Timeout

public sealed class Timer	public sealed class Timer
: IDisposable	: MarshalByRefObject, IDisposable
public Boolean Change(Int32 dueTime, Int32 period);	public Boolean Change(Int32 dueTime, Int32 period);
public Boolean Change(TimeSpan dueTime, TimeSpan period);	public Boolean Change(TimeSpan dueTime, TimeSpan period);
public Boolean Change(UInt32 dueTime, UInt32 period);	public Boolean Change(UInt32 dueTime, UInt32 period);
public Boolean Change(Int64 dueTime, Int64 period);	public Boolean Change(Int64 dueTime, Int64 period);
public Boolean Dispose(WaitHandle notifyObject);	public Boolean Dispose(WaitHandle notifyObject);
public virtual void Dispose();	public virtual void Dispose();

public sealed class TimerCallback	public sealed class TimerCallback
: MulticastDelegate, ICloneable	: MulticastDelegate, ICloneable, ISerializable
public virtual IAsyncResult BeginInvoke(Object state, AsyncCallback callback, Object object);	public virtual IAsyncResult BeginInvoke(Object state, AsyncCallback callback, Object object);
public virtual void EndInvoke(IAsyncResult result);	public virtual void EndInvoke(IAsyncResult result);
public virtual void Invoke(Object state);	public virtual void Invoke(Object state);

	public abstract sealed class Volatile
	static public Int64 Read(Int64& location);
	static public Boolean Read(Boolean& location);
	static public SByte Read(SByte& location);
	static public Byte Read(Byte& location);
	static public Int16 Read(Int16& location);
	static public UInt16 Read(UInt16& location);
	static public Int32 Read(Int32& location);
	static public UInt32 Read(UInt32& location);
	static public UInt64 Read(UInt64& location);
	static public IntPtr Read(IntPtr& location);
	static public UIntPtr Read(UIntPtr& location);
	static public Single Read(Single& location);
	static public Double Read(Double& location);
	static public T Read(T& location);
	static public void Write(Int64& location, Int64 value);
	static public void Write(Boolean& location, Boolean value);
	static public void Write(SByte& location, SByte value);
	static public void Write(Byte& location, Byte value);
	static public void Write(Int16& location, Int16 value);
	static public void Write(UInt16& location, UInt16 value);
	static public void Write(Int32& location, Int32 value);
	static public void Write(UInt32& location, UInt32 value);
	static public void Write(UInt64& location, UInt64 value);
	static public void Write(IntPtr& location, IntPtr value);
	static public void Write(UIntPtr& location, UIntPtr value);
	static public void Write(Single& location, Single value);
	static public void Write(Double& location, Double value);
	static public void Write(T& location, T value);

public sealed class WaitCallback	public sealed class WaitCallback
: MulticastDelegate, ICloneable	: MulticastDelegate, ICloneable, ISerializable
public virtual IAsyncResult BeginInvoke(Object state, AsyncCallback callback, Object object);	public virtual IAsyncResult BeginInvoke(Object state, AsyncCallback callback, Object object);
public virtual void EndInvoke(IAsyncResult result);	public virtual void EndInvoke(IAsyncResult result);
public virtual void Invoke(Object state);	public virtual void Invoke(Object state);

public abstract class WaitHandle	public abstract class WaitHandle
: IDisposable	: MarshalByRefObject, IDisposable
	public virtual IntPtr Handle { get; set; }
	public SafeWaitHandle SafeWaitHandle { get; set; }
public virtual void Close();	public virtual void Close();
	protected virtual void Dispose(Boolean explicitDisposing);
public virtual void Dispose();	public virtual void Dispose();
	static public Boolean SignalAndWait(WaitHandle toSignal, WaitHandle toWaitOn);
	static public Boolean SignalAndWait(WaitHandle toSignal, WaitHandle toWaitOn, TimeSpan timeout, Boolean exitContext);
	static public Boolean SignalAndWait(WaitHandle toSignal, WaitHandle toWaitOn, Int32 millisecondsTimeout, Boolean exitContext);
	static public Boolean WaitAll(WaitHandle waitHandles, Int32 millisecondsTimeout, Boolean exitContext);
	static public Boolean WaitAll(WaitHandle waitHandles, TimeSpan timeout, Boolean exitContext);
static public Boolean WaitAll(WaitHandle waitHandles);	static public Boolean WaitAll(WaitHandle waitHandles);
static public Boolean WaitAll(WaitHandle waitHandles, Int32 millisecondsTimeout);	static public Boolean WaitAll(WaitHandle waitHandles, Int32 millisecondsTimeout);
static public Boolean WaitAll(WaitHandle waitHandles, TimeSpan timeout);	static public Boolean WaitAll(WaitHandle waitHandles, TimeSpan timeout);
	static public Int32 WaitAny(WaitHandle waitHandles, Int32 millisecondsTimeout, Boolean exitContext);
	static public Int32 WaitAny(WaitHandle waitHandles, TimeSpan timeout, Boolean exitContext);
static public Int32 WaitAny(WaitHandle waitHandles, TimeSpan timeout);	static public Int32 WaitAny(WaitHandle waitHandles, TimeSpan timeout);
static public Int32 WaitAny(WaitHandle waitHandles);	static public Int32 WaitAny(WaitHandle waitHandles);
static public Int32 WaitAny(WaitHandle waitHandles, Int32 millisecondsTimeout);	static public Int32 WaitAny(WaitHandle waitHandles, Int32 millisecondsTimeout);
	public virtual Boolean WaitOne(Int32 millisecondsTimeout, Boolean exitContext);
	public virtual Boolean WaitOne(TimeSpan timeout, Boolean exitContext);
public virtual Boolean WaitOne();	public virtual Boolean WaitOne();
public virtual Boolean WaitOne(Int32 millisecondsTimeout);	public virtual Boolean WaitOne(Int32 millisecondsTimeout);
public virtual Boolean WaitOne(TimeSpan timeout);	public virtual Boolean WaitOne(TimeSpan timeout);

	public class WaitHandleCannotBeOpenedException
	: ApplicationException, ISerializable, _Exception

public sealed class WaitOrTimerCallback	public sealed class WaitOrTimerCallback
: MulticastDelegate, ICloneable	: MulticastDelegate, ICloneable, ISerializable
public virtual IAsyncResult BeginInvoke(Object state, Boolean timedOut, AsyncCallback callback, Object object);	public virtual IAsyncResult BeginInvoke(Object state, Boolean timedOut, AsyncCallback callback, Object object);
public virtual void EndInvoke(IAsyncResult result);	public virtual void EndInvoke(IAsyncResult result);
public virtual void Invoke(Object state, Boolean timedOut);	public virtual void Invoke(Object state, Boolean timedOut);